metal-orm 1.0.32 → 1.0.34

package/dist/decorators/index.cjs

@@ -1,4968 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/decorators/index.ts
-var decorators_exports = {};
-__export(decorators_exports, {
-  BelongsTo: () => BelongsTo,
-  BelongsToMany: () => BelongsToMany,
-  Column: () => Column,
-  Entity: () => Entity,
-  HasMany: () => HasMany,
-  HasOne: () => HasOne,
-  PrimaryKey: () => PrimaryKey,
-  bootstrapEntities: () => bootstrapEntities,
-  getTableDefFromEntity: () => getTableDefFromEntity,
-  selectFromEntity: () => selectFromEntity
-});
-module.exports = __toCommonJS(decorators_exports);
-
-// src/schema/table.ts
-var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
-  const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
-    acc[key] = { ...def, name: key, table: name };
-    return acc;
-  }, {});
-  return {
-    name,
-    schema: options.schema,
-    columns: colsWithNames,
-    relations,
-    hooks,
-    primaryKey: options.primaryKey,
-    indexes: options.indexes,
-    checks: options.checks,
-    comment: options.comment,
-    engine: options.engine,
-    charset: options.charset,
-    collation: options.collation
-  };
-};
-
-// src/orm/entity-metadata.ts
-var metadataMap = /* @__PURE__ */ new Map();
-var ensureEntityMetadata = (target) => {
-  let meta = metadataMap.get(target);
-  if (!meta) {
-    meta = {
-      target,
-      tableName: target.name || "unknown",
-      columns: {},
-      relations: {}
-    };
-    metadataMap.set(target, meta);
-  }
-  return meta;
-};
-var getEntityMetadata = (target) => {
-  return metadataMap.get(target);
-};
-var getAllEntityMetadata = () => {
-  return Array.from(metadataMap.values());
-};
-var addColumnMetadata = (target, propertyKey, column) => {
-  const meta = ensureEntityMetadata(target);
-  meta.columns[propertyKey] = { ...column };
-};
-var addRelationMetadata = (target, propertyKey, relation) => {
-  const meta = ensureEntityMetadata(target);
-  meta.relations[propertyKey] = relation;
-};
-var setEntityTableName = (target, tableName, hooks) => {
-  const meta = ensureEntityMetadata(target);
-  if (tableName && tableName.length > 0) {
-    meta.tableName = tableName;
-  }
-  if (hooks) {
-    meta.hooks = hooks;
-  }
-};
-var buildTableDef = (meta) => {
-  if (meta.table) {
-    return meta.table;
-  }
-  const columns = Object.entries(meta.columns).reduce((acc, [key, def]) => {
-    acc[key] = {
-      ...def,
-      name: key,
-      table: meta.tableName
-    };
-    return acc;
-  }, {});
-  const table = defineTable(meta.tableName, columns, {}, meta.hooks);
-  meta.table = table;
-  return table;
-};
-
-// src/decorators/decorator-metadata.ts
-var METADATA_KEY = "metal-orm:decorators";
-var isStandardDecoratorContext = (value) => {
-  return typeof value === "object" && value !== null && "kind" in value;
-};
-var getOrCreateMetadataBag = (context) => {
-  const metadata = context.metadata || (context.metadata = {});
-  const existing = metadata[METADATA_KEY];
-  if (existing) {
-    return existing;
-  }
-  const bag = { columns: [], relations: [] };
-  metadata[METADATA_KEY] = bag;
-  return bag;
-};
-var readMetadataBag = (context) => {
-  return context.metadata?.[METADATA_KEY];
-};
-var registerInitializer = (context, initializer) => {
-  context.addInitializer?.(initializer);
-};
-
-// src/decorators/entity.ts
-var toSnakeCase = (value) => {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_]+/gi, "_").replace(/__+/g, "_").replace(/^_|_$/g, "").toLowerCase();
-};
-var deriveTableNameFromConstructor = (ctor) => {
-  const fallback = "unknown";
-  const rawName = ctor.name || fallback;
-  const strippedName = rawName.replace(/Entity$/i, "");
-  const normalized = toSnakeCase(strippedName || rawName);
-  if (!normalized) {
-    return fallback;
-  }
-  return normalized.endsWith("s") ? normalized : `${normalized}s`;
-};
-function Entity(options = {}) {
-  const decorator = (value) => {
-    const tableName = options.tableName ?? deriveTableNameFromConstructor(value);
-    setEntityTableName(value, tableName, options.hooks);
-    return value;
-  };
-  const decoratorWithContext = (value, context) => {
-    const ctor = value;
-    decorator(ctor);
-    if (context && isStandardDecoratorContext(context)) {
-      const bag = readMetadataBag(context);
-      if (bag) {
-        const meta = ensureEntityMetadata(ctor);
-        for (const entry of bag.columns) {
-          if (!meta.columns[entry.propertyName]) {
-            addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
-          }
-        }
-        for (const entry of bag.relations) {
-          if (!meta.relations[entry.propertyName]) {
-            addRelationMetadata(ctor, entry.propertyName, entry.relation);
-          }
-        }
-      }
-    }
-    return ctor;
-  };
-  return decoratorWithContext;
-}
-
-// src/decorators/column.ts
-var normalizeColumnInput = (input) => {
-  const asOptions = input;
-  const asDefinition = input;
-  const column = {
-    type: asOptions.type ?? asDefinition.type,
-    args: asOptions.args ?? asDefinition.args,
-    notNull: asOptions.notNull ?? asDefinition.notNull,
-    primary: asOptions.primary ?? asDefinition.primary,
-    unique: asDefinition.unique,
-    default: asDefinition.default,
-    autoIncrement: asDefinition.autoIncrement,
-    generated: asDefinition.generated,
-    check: asDefinition.check,
-    references: asDefinition.references,
-    comment: asDefinition.comment
-  };
-  if (!column.type) {
-    throw new Error("Column decorator requires a column type");
-  }
-  return column;
-};
-var normalizePropertyName = (name) => {
-  if (typeof name === "symbol") {
-    return name.description ?? name.toString();
-  }
-  return name;
-};
-var resolveConstructor = (target) => {
-  if (typeof target === "function") {
-    return target;
-  }
-  if (target && typeof target.constructor === "function") {
-    return target.constructor;
-  }
-  return void 0;
-};
-var registerColumn = (ctor, propertyName, column) => {
-  const meta = ensureEntityMetadata(ctor);
-  if (meta.columns[propertyName]) {
-    return;
-  }
-  addColumnMetadata(ctor, propertyName, column);
-};
-var registerColumnFromContext = (context, column) => {
-  if (!context.name) {
-    throw new Error("Column decorator requires a property name");
-  }
-  const propertyName = normalizePropertyName(context.name);
-  const bag = getOrCreateMetadataBag(context);
-  if (!bag.columns.some((entry) => entry.propertyName === propertyName)) {
-    bag.columns.push({ propertyName, column: { ...column } });
-  }
-  registerInitializer(context, function() {
-    const ctor = resolveConstructor(this);
-    if (!ctor) {
-      return;
-    }
-    registerColumn(ctor, propertyName, column);
-  });
-};
-function Column(definition) {
-  const normalized = normalizeColumnInput(definition);
-  const decorator = (targetOrValue, propertyKeyOrContext) => {
-    if (isStandardDecoratorContext(propertyKeyOrContext)) {
-      registerColumnFromContext(propertyKeyOrContext, normalized);
-      return;
-    }
-    const propertyName = normalizePropertyName(propertyKeyOrContext);
-    const ctor = resolveConstructor(targetOrValue);
-    if (!ctor) {
-      throw new Error("Unable to resolve constructor when registering column metadata");
-    }
-    registerColumn(ctor, propertyName, { ...normalized });
-  };
-  return decorator;
-}
-function PrimaryKey(definition) {
-  const normalized = normalizeColumnInput(definition);
-  normalized.primary = true;
-  return Column(normalized);
-}
-
-// src/schema/relation.ts
-var RelationKinds = {
-  /** One-to-one relationship */
-  HasOne: "HAS_ONE",
-  /** One-to-many relationship */
-  HasMany: "HAS_MANY",
-  /** Many-to-one relationship */
-  BelongsTo: "BELONGS_TO",
-  /** Many-to-many relationship with pivot metadata */
-  BelongsToMany: "BELONGS_TO_MANY"
-};
-var hasMany = (target, foreignKey, localKey, cascade) => ({
-  type: RelationKinds.HasMany,
-  target,
-  foreignKey,
-  localKey,
-  cascade
-});
-var hasOne = (target, foreignKey, localKey, cascade) => ({
-  type: RelationKinds.HasOne,
-  target,
-  foreignKey,
-  localKey,
-  cascade
-});
-var belongsTo = (target, foreignKey, localKey, cascade) => ({
-  type: RelationKinds.BelongsTo,
-  target,
-  foreignKey,
-  localKey,
-  cascade
-});
-var belongsToMany = (target, pivotTable, options) => ({
-  type: RelationKinds.BelongsToMany,
-  target,
-  pivotTable,
-  pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
-  pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
-  localKey: options.localKey,
-  targetKey: options.targetKey,
-  pivotPrimaryKey: options.pivotPrimaryKey,
-  defaultPivotColumns: options.defaultPivotColumns,
-  cascade: options.cascade
-});
-
-// src/decorators/relations.ts
-var normalizePropertyName2 = (name) => {
-  if (typeof name === "symbol") {
-    return name.description ?? name.toString();
-  }
-  return name;
-};
-var resolveConstructor2 = (instanceOrCtor) => {
-  if (typeof instanceOrCtor === "function") {
-    return instanceOrCtor;
-  }
-  if (instanceOrCtor && typeof instanceOrCtor.constructor === "function") {
-    return instanceOrCtor.constructor;
-  }
-  return void 0;
-};
-var registerRelation = (ctor, propertyName, metadata) => {
-  addRelationMetadata(ctor, propertyName, metadata);
-};
-var createFieldDecorator = (metadataFactory) => {
-  const decorator = (targetOrValue, propertyKeyOrContext) => {
-    if (isStandardDecoratorContext(propertyKeyOrContext)) {
-      const ctx = propertyKeyOrContext;
-      if (!ctx.name) {
-        throw new Error("Relation decorator requires a property name");
-      }
-      const propertyName2 = normalizePropertyName2(ctx.name);
-      const bag = getOrCreateMetadataBag(ctx);
-      const relationMetadata = metadataFactory(propertyName2);
-      if (!bag.relations.some((entry) => entry.propertyName === propertyName2)) {
-        bag.relations.push({ propertyName: propertyName2, relation: relationMetadata });
-      }
-      registerInitializer(ctx, function() {
-        const ctor2 = resolveConstructor2(this);
-        if (!ctor2) {
-          return;
-        }
-        registerRelation(ctor2, propertyName2, relationMetadata);
-      });
-      return;
-    }
-    const propertyName = normalizePropertyName2(propertyKeyOrContext);
-    const ctor = resolveConstructor2(targetOrValue);
-    if (!ctor) {
-      throw new Error("Unable to resolve constructor when registering relation metadata");
-    }
-    registerRelation(ctor, propertyName, metadataFactory(propertyName));
-  };
-  return decorator;
-};
-function HasMany(options) {
-  return createFieldDecorator((propertyName) => ({
-    kind: RelationKinds.HasMany,
-    propertyKey: propertyName,
-    target: options.target,
-    foreignKey: options.foreignKey,
-    localKey: options.localKey,
-    cascade: options.cascade
-  }));
-}
-function HasOne(options) {
-  return createFieldDecorator((propertyName) => ({
-    kind: RelationKinds.HasOne,
-    propertyKey: propertyName,
-    target: options.target,
-    foreignKey: options.foreignKey,
-    localKey: options.localKey,
-    cascade: options.cascade
-  }));
-}
-function BelongsTo(options) {
-  return createFieldDecorator((propertyName) => ({
-    kind: RelationKinds.BelongsTo,
-    propertyKey: propertyName,
-    target: options.target,
-    foreignKey: options.foreignKey,
-    localKey: options.localKey,
-    cascade: options.cascade
-  }));
-}
-function BelongsToMany(options) {
-  return createFieldDecorator((propertyName) => ({
-    kind: RelationKinds.BelongsToMany,
-    propertyKey: propertyName,
-    target: options.target,
-    pivotTable: options.pivotTable,
-    pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
-    pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
-    localKey: options.localKey,
-    targetKey: options.targetKey,
-    pivotPrimaryKey: options.pivotPrimaryKey,
-    defaultPivotColumns: options.defaultPivotColumns,
-    cascade: options.cascade
-  }));
-}
-
-// src/core/ast/expression-nodes.ts
-var operandTypes = /* @__PURE__ */ new Set([
-  "Column",
-  "Literal",
-  "Function",
-  "JsonPath",
-  "ScalarSubquery",
-  "CaseExpression",
-  "WindowFunction"
-]);
-var isOperandNode = (node) => node && operandTypes.has(node.type);
-var isFunctionNode = (node) => node?.type === "Function";
-var isCaseExpressionNode = (node) => node?.type === "CaseExpression";
-var isWindowFunctionNode = (node) => node?.type === "WindowFunction";
-var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
-
-// src/core/ast/expression-builders.ts
-var valueToOperand = (value) => {
-  if (isOperandNode(value)) {
-    return value;
-  }
-  return {
-    type: "Literal",
-    value
-  };
-};
-var toNode = (col) => {
-  if (isOperandNode(col)) return col;
-  const def = col;
-  return { type: "Column", table: def.table || "unknown", name: def.name };
-};
-var toLiteralNode = (value) => ({
-  type: "Literal",
-  value
-});
-var isLiteralValue = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-var toOperand = (val) => {
-  if (isLiteralValue(val)) {
-    return valueToOperand(val);
-  }
-  return toNode(val);
-};
-var columnOperand = (col) => toNode(col);
-var createBinaryExpression = (operator, left, right, escape) => {
-  const node = {
-    type: "BinaryExpression",
-    left: toNode(left),
-    operator,
-    right: toOperand(right)
-  };
-  if (escape !== void 0) {
-    node.escape = toLiteralNode(escape);
-  }
-  return node;
-};
-var eq = (left, right) => createBinaryExpression("=", left, right);
-var and = (...operands) => ({
-  type: "LogicalExpression",
-  operator: "AND",
-  operands
-});
-var createInExpression = (operator, left, values) => ({
-  type: "InExpression",
-  left: toNode(left),
-  operator,
-  right: values.map((v) => toOperand(v))
-});
-var inList = (left, values) => createInExpression("IN", left, values);
-var exists = (subquery) => ({
-  type: "ExistsExpression",
-  operator: "EXISTS",
-  subquery
-});
-var notExists = (subquery) => ({
-  type: "ExistsExpression",
-  operator: "NOT EXISTS",
-  subquery
-});
-
-// src/core/sql/sql.ts
-var JOIN_KINDS = {
-  /** INNER JOIN type */
-  INNER: "INNER",
-  /** LEFT JOIN type */
-  LEFT: "LEFT",
-  /** RIGHT JOIN type */
-  RIGHT: "RIGHT",
-  /** CROSS JOIN type */
-  CROSS: "CROSS"
-};
-var ORDER_DIRECTIONS = {
-  /** Ascending order */
-  ASC: "ASC",
-  /** Descending order */
-  DESC: "DESC"
-};
-
-// src/core/ast/aggregate-functions.ts
-var buildAggregate = (name) => (col) => ({
-  type: "Function",
-  name,
-  args: [columnOperand(col)]
-});
-var count = buildAggregate("COUNT");
-var sum = buildAggregate("SUM");
-var avg = buildAggregate("AVG");
-var min = buildAggregate("MIN");
-var max = buildAggregate("MAX");
-
-// src/core/ast/builders.ts
-var buildColumnNode = (table, column) => {
-  if (column.type === "Column") {
-    return column;
-  }
-  const def = column;
-  const baseTable = def.table ? table.alias && def.table === table.name ? table.alias : def.table : table.alias || table.name;
-  return {
-    type: "Column",
-    table: baseTable,
-    name: def.name
-  };
-};
-var derivedTable = (query, alias, columnAliases) => ({
-  type: "DerivedTable",
-  query,
-  alias,
-  columnAliases
-});
-
-// src/core/functions/standard-strategy.ts
-var StandardFunctionStrategy = class _StandardFunctionStrategy {
-  constructor() {
-    this.renderers = /* @__PURE__ */ new Map();
-    this.registerStandard();
-  }
-  registerStandard() {
-    this.add("COUNT", ({ compiledArgs }) => `COUNT(${compiledArgs.join(", ")})`);
-    this.add("SUM", ({ compiledArgs }) => `SUM(${compiledArgs[0]})`);
-    this.add("AVG", ({ compiledArgs }) => `AVG(${compiledArgs[0]})`);
-    this.add("MIN", ({ compiledArgs }) => `MIN(${compiledArgs[0]})`);
-    this.add("MAX", ({ compiledArgs }) => `MAX(${compiledArgs[0]})`);
-    this.add("ABS", ({ compiledArgs }) => `ABS(${compiledArgs[0]})`);
-    this.add("UPPER", ({ compiledArgs }) => `UPPER(${compiledArgs[0]})`);
-    this.add("LOWER", ({ compiledArgs }) => `LOWER(${compiledArgs[0]})`);
-    this.add("LENGTH", ({ compiledArgs }) => `LENGTH(${compiledArgs[0]})`);
-    this.add("TRIM", ({ compiledArgs }) => `TRIM(${compiledArgs[0]})`);
-    this.add("LTRIM", ({ compiledArgs }) => `LTRIM(${compiledArgs[0]})`);
-    this.add("RTRIM", ({ compiledArgs }) => `RTRIM(${compiledArgs[0]})`);
-    this.add("SUBSTRING", ({ compiledArgs }) => `SUBSTRING(${compiledArgs.join(", ")})`);
-    this.add("CONCAT", ({ compiledArgs }) => `CONCAT(${compiledArgs.join(", ")})`);
-    this.add("NOW", () => `NOW()`);
-    this.add("CURRENT_DATE", () => `CURRENT_DATE`);
-    this.add("CURRENT_TIME", () => `CURRENT_TIME`);
-    this.add("EXTRACT", ({ compiledArgs }) => `EXTRACT(${compiledArgs[0]} FROM ${compiledArgs[1]})`);
-    this.add("YEAR", ({ compiledArgs }) => `EXTRACT(YEAR FROM ${compiledArgs[0]})`);
-    this.add("MONTH", ({ compiledArgs }) => `EXTRACT(MONTH FROM ${compiledArgs[0]})`);
-    this.add("DAY", ({ compiledArgs }) => `EXTRACT(DAY FROM ${compiledArgs[0]})`);
-    this.add("DATE_ADD", ({ compiledArgs }) => `(${compiledArgs[0]} + INTERVAL ${compiledArgs[1]} ${compiledArgs[2]})`);
-    this.add("DATE_SUB", ({ compiledArgs }) => `(${compiledArgs[0]} - INTERVAL ${compiledArgs[1]} ${compiledArgs[2]})`);
-    this.add("DATE_DIFF", ({ compiledArgs }) => `DATEDIFF(${compiledArgs[0]}, ${compiledArgs[1]})`);
-    this.add("DATE_FORMAT", ({ compiledArgs }) => `DATE_FORMAT(${compiledArgs[0]}, ${compiledArgs[1]})`);
-    this.add("UNIX_TIMESTAMP", () => `UNIX_TIMESTAMP()`);
-    this.add("FROM_UNIXTIME", ({ compiledArgs }) => `FROM_UNIXTIME(${compiledArgs[0]})`);
-    this.add("END_OF_MONTH", ({ compiledArgs }) => `LAST_DAY(${compiledArgs[0]})`);
-    this.add("DAY_OF_WEEK", ({ compiledArgs }) => `DAYOFWEEK(${compiledArgs[0]})`);
-    this.add("WEEK_OF_YEAR", ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})`);
-    this.add("DATE_TRUNC", ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})`);
-    this.add("GROUP_CONCAT", (ctx) => this.renderGroupConcat(ctx));
-  }
-  add(name, renderer) {
-    this.renderers.set(name, renderer);
-  }
-  getRenderer(name) {
-    return this.renderers.get(name);
-  }
-  renderGroupConcat(ctx) {
-    const arg = ctx.compiledArgs[0];
-    const orderClause = this.buildOrderByExpression(ctx);
-    const orderSegment = orderClause ? ` ${orderClause}` : "";
-    const separatorClause = this.formatGroupConcatSeparator(ctx);
-    return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
-  }
-  buildOrderByExpression(ctx) {
-    const orderBy = ctx.node.orderBy;
-    if (!orderBy || orderBy.length === 0) {
-      return "";
-    }
-    const parts = orderBy.map((order) => `${ctx.compileOperand(order.column)} ${order.direction}`);
-    return `ORDER BY ${parts.join(", ")}`;
-  }
-  formatGroupConcatSeparator(ctx) {
-    if (!ctx.node.separator) {
-      return "";
-    }
-    return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
-  }
-  getGroupConcatSeparatorOperand(ctx) {
-    return ctx.node.separator ?? _StandardFunctionStrategy.DEFAULT_GROUP_CONCAT_SEPARATOR;
-  }
-  static {
-    this.DEFAULT_GROUP_CONCAT_SEPARATOR = {
-      type: "Literal",
-      value: ","
-    };
-  }
-};
-
-// src/core/dialect/abstract.ts
-var Dialect = class _Dialect {
-  /**
-   * Compiles a SELECT query AST to SQL
-   * @param ast - Query AST to compile
-   * @returns Compiled query with SQL and parameters
-   */
-  compileSelect(ast) {
-    const ctx = this.createCompilerContext();
-    const normalized = this.normalizeSelectAst(ast);
-    const rawSql = this.compileSelectAst(normalized, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileInsert(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileInsertAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileUpdate(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileUpdateAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileDelete(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileDeleteAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  supportsReturning() {
-    return false;
-  }
-  /**
-   * Compiles a WHERE clause
-   * @param where - WHERE expression
-   * @param ctx - Compiler context
-   * @returns SQL WHERE clause or empty string
-   */
-  compileWhere(where, ctx) {
-    if (!where) return "";
-    return ` WHERE ${this.compileExpression(where, ctx)}`;
-  }
-  compileReturning(returning, ctx) {
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  /**
-   * Generates subquery for EXISTS expressions
-   * Rule: Always forces SELECT 1, ignoring column list
-   * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
-   * Does not add ';' at the end
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL for EXISTS subquery
-   */
-  compileSelectForExists(ast, ctx) {
-    const normalized = this.normalizeSelectAst(ast);
-    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
-    if (normalized.setOps && normalized.setOps.length > 0) {
-      return `SELECT 1 FROM (${full}) AS _exists`;
-    }
-    const upper = full.toUpperCase();
-    const fromIndex = upper.indexOf(" FROM ");
-    if (fromIndex === -1) {
-      return full;
-    }
-    const tail = full.slice(fromIndex);
-    return `SELECT 1${tail}`;
-  }
-  /**
-   * Creates a new compiler context
-   * @returns Compiler context with parameter management
-   */
-  createCompilerContext() {
-    const params = [];
-    let counter = 0;
-    return {
-      params,
-      addParameter: (value) => {
-        counter += 1;
-        params.push(value);
-        return this.formatPlaceholder(counter);
-      }
-    };
-  }
-  /**
-   * Formats a parameter placeholder
-   * @param index - Parameter index
-   * @returns Formatted placeholder string
-   */
-  formatPlaceholder(index) {
-    return "?";
-  }
-  /**
-   * Whether the current dialect supports a given set operation.
-   * Override in concrete dialects to restrict support.
-   */
-  supportsSetOperation(kind) {
-    return true;
-  }
-  /**
-   * Validates set-operation semantics:
-   * - Ensures the dialect supports requested operators.
-   * - Enforces that only the outermost compound query may have ORDER/LIMIT/OFFSET.
-   * @param ast - Query to validate
-   * @param isOutermost - Whether this node is the outermost compound query
-   */
-  validateSetOperations(ast, isOutermost = true) {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    if (!isOutermost && (ast.orderBy || ast.limit !== void 0 || ast.offset !== void 0)) {
-      throw new Error("ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.");
-    }
-    if (hasSetOps) {
-      for (const op of ast.setOps) {
-        if (!this.supportsSetOperation(op.operator)) {
-          throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
-        }
-        this.validateSetOperations(op.query, false);
-      }
-    }
-  }
-  /**
-   * Hoists CTEs from set-operation operands to the outermost query so WITH appears once.
-   * @param ast - Query AST
-   * @returns Normalized AST without inner CTEs and a list of hoisted CTEs
-   */
-  hoistCtes(ast) {
-    let hoisted = [];
-    const normalizedSetOps = ast.setOps?.map((op) => {
-      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
-      const childCtes = child.ctes ?? [];
-      if (childCtes.length) {
-        hoisted = hoisted.concat(childCtes);
-      }
-      hoisted = hoisted.concat(childHoisted);
-      const queryWithoutCtes = childCtes.length ? { ...child, ctes: void 0 } : child;
-      return { ...op, query: queryWithoutCtes };
-    });
-    const normalized = normalizedSetOps ? { ...ast, setOps: normalizedSetOps } : ast;
-    return { normalized, hoistedCtes: hoisted };
-  }
-  /**
-   * Normalizes a SELECT AST before compilation (validation + CTE hoisting).
-   * @param ast - Query AST
-   * @returns Normalized query AST
-   */
-  normalizeSelectAst(ast) {
-    this.validateSetOperations(ast, true);
-    const { normalized, hoistedCtes } = this.hoistCtes(ast);
-    const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
-    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
-  }
-  constructor(functionStrategy) {
-    this.expressionCompilers = /* @__PURE__ */ new Map();
-    this.operandCompilers = /* @__PURE__ */ new Map();
-    this.functionStrategy = functionStrategy || new StandardFunctionStrategy();
-    this.registerDefaultOperandCompilers();
-    this.registerDefaultExpressionCompilers();
-  }
-  /**
-   * Creates a new Dialect instance (for testing purposes)
-   * @param functionStrategy - Optional function strategy
-   * @returns New Dialect instance
-   */
-  static create(functionStrategy) {
-    class TestDialect extends _Dialect {
-      constructor() {
-        super(...arguments);
-        this.dialect = "sqlite";
-      }
-      quoteIdentifier(id) {
-        return `"${id}"`;
-      }
-      compileSelectAst() {
-        throw new Error("Not implemented");
-      }
-      compileInsertAst() {
-        throw new Error("Not implemented");
-      }
-      compileUpdateAst() {
-        throw new Error("Not implemented");
-      }
-      compileDeleteAst() {
-        throw new Error("Not implemented");
-      }
-    }
-    return new TestDialect(functionStrategy);
-  }
-  /**
-   * Registers an expression compiler for a specific node type
-   * @param type - Expression node type
-   * @param compiler - Compiler function
-   */
-  registerExpressionCompiler(type, compiler) {
-    this.expressionCompilers.set(type, compiler);
-  }
-  /**
-   * Registers an operand compiler for a specific node type
-   * @param type - Operand node type
-   * @param compiler - Compiler function
-   */
-  registerOperandCompiler(type, compiler) {
-    this.operandCompilers.set(type, compiler);
-  }
-  /**
-   * Compiles an expression node
-   * @param node - Expression node to compile
-   * @param ctx - Compiler context
-   * @returns Compiled SQL expression
-   */
-  compileExpression(node, ctx) {
-    const compiler = this.expressionCompilers.get(node.type);
-    if (!compiler) {
-      throw new Error(`Unsupported expression node type "${node.type}" for ${this.constructor.name}`);
-    }
-    return compiler(node, ctx);
-  }
-  /**
-   * Compiles an operand node
-   * @param node - Operand node to compile
-   * @param ctx - Compiler context
-   * @returns Compiled SQL operand
-   */
-  compileOperand(node, ctx) {
-    const compiler = this.operandCompilers.get(node.type);
-    if (!compiler) {
-      throw new Error(`Unsupported operand node type "${node.type}" for ${this.constructor.name}`);
-    }
-    return compiler(node, ctx);
-  }
-  registerDefaultExpressionCompilers() {
-    this.registerExpressionCompiler("BinaryExpression", (binary, ctx) => {
-      const left = this.compileOperand(binary.left, ctx);
-      const right = this.compileOperand(binary.right, ctx);
-      const base = `${left} ${binary.operator} ${right}`;
-      if (binary.escape) {
-        const escapeOperand = this.compileOperand(binary.escape, ctx);
-        return `${base} ESCAPE ${escapeOperand}`;
-      }
-      return base;
-    });
-    this.registerExpressionCompiler("LogicalExpression", (logical, ctx) => {
-      if (logical.operands.length === 0) return "";
-      const parts = logical.operands.map((op) => {
-        const compiled = this.compileExpression(op, ctx);
-        return op.type === "LogicalExpression" ? `(${compiled})` : compiled;
-      });
-      return parts.join(` ${logical.operator} `);
-    });
-    this.registerExpressionCompiler("NullExpression", (nullExpr, ctx) => {
-      const left = this.compileOperand(nullExpr.left, ctx);
-      return `${left} ${nullExpr.operator}`;
-    });
-    this.registerExpressionCompiler("InExpression", (inExpr, ctx) => {
-      const left = this.compileOperand(inExpr.left, ctx);
-      const values = inExpr.right.map((v) => this.compileOperand(v, ctx)).join(", ");
-      return `${left} ${inExpr.operator} (${values})`;
-    });
-    this.registerExpressionCompiler("ExistsExpression", (existsExpr, ctx) => {
-      const subquerySql = this.compileSelectForExists(existsExpr.subquery, ctx);
-      return `${existsExpr.operator} (${subquerySql})`;
-    });
-    this.registerExpressionCompiler("BetweenExpression", (betweenExpr, ctx) => {
-      const left = this.compileOperand(betweenExpr.left, ctx);
-      const lower = this.compileOperand(betweenExpr.lower, ctx);
-      const upper = this.compileOperand(betweenExpr.upper, ctx);
-      return `${left} ${betweenExpr.operator} ${lower} AND ${upper}`;
-    });
-  }
-  registerDefaultOperandCompilers() {
-    this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
-    this.registerOperandCompiler("Column", (column, _ctx) => {
-      return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
-    });
-    this.registerOperandCompiler(
-      "Function",
-      (fnNode, ctx) => this.compileFunctionOperand(fnNode, ctx)
-    );
-    this.registerOperandCompiler("JsonPath", (path, _ctx) => this.compileJsonPath(path));
-    this.registerOperandCompiler("ScalarSubquery", (node, ctx) => {
-      const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
-      return `(${sql})`;
-    });
-    this.registerOperandCompiler("CaseExpression", (node, ctx) => {
-      const parts = ["CASE"];
-      for (const { when, then } of node.conditions) {
-        parts.push(`WHEN ${this.compileExpression(when, ctx)} THEN ${this.compileOperand(then, ctx)}`);
-      }
-      if (node.else) {
-        parts.push(`ELSE ${this.compileOperand(node.else, ctx)}`);
-      }
-      parts.push("END");
-      return parts.join(" ");
-    });
-    this.registerOperandCompiler("WindowFunction", (node, ctx) => {
-      let result = `${node.name}(`;
-      if (node.args.length > 0) {
-        result += node.args.map((arg) => this.compileOperand(arg, ctx)).join(", ");
-      }
-      result += ") OVER (";
-      const parts = [];
-      if (node.partitionBy && node.partitionBy.length > 0) {
-        const partitionClause = "PARTITION BY " + node.partitionBy.map(
-          (col) => `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`
-        ).join(", ");
-        parts.push(partitionClause);
-      }
-      if (node.orderBy && node.orderBy.length > 0) {
-        const orderClause = "ORDER BY " + node.orderBy.map(
-          (o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`
-        ).join(", ");
-        parts.push(orderClause);
-      }
-      result += parts.join(" ");
-      result += ")";
-      return result;
-    });
-  }
-  // Default fallback, should be overridden by dialects if supported
-  compileJsonPath(node) {
-    throw new Error("JSON Path not supported by this dialect");
-  }
-  /**
-   * Compiles a function operand, using the dialect's function strategy.
-   */
-  compileFunctionOperand(fnNode, ctx) {
-    const compiledArgs = fnNode.args.map((arg) => this.compileOperand(arg, ctx));
-    const renderer = this.functionStrategy.getRenderer(fnNode.name);
-    if (renderer) {
-      return renderer({
-        node: fnNode,
-        compiledArgs,
-        compileOperand: (operand) => this.compileOperand(operand, ctx)
-      });
-    }
-    return `${fnNode.name}(${compiledArgs.join(", ")})`;
-  }
-};
-
-// src/core/dialect/base/function-table-formatter.ts
-var FunctionTableFormatter = class {
-  /**
-   * Formats a function table node into SQL syntax.
-   * @param fn - The function table node containing schema, name, args, and aliases.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns SQL function table expression (e.g., "LATERAL schema.func(args) WITH ORDINALITY AS alias(col1, col2)").
-   */
-  static format(fn, ctx, dialect) {
-    const schemaPart = this.formatSchema(fn, dialect);
-    const args = this.formatArgs(fn, ctx, dialect);
-    const base = this.formatBase(fn, schemaPart, args, dialect);
-    const lateral = this.formatLateral(fn);
-    const alias = this.formatAlias(fn, dialect);
-    const colAliases = this.formatColumnAliases(fn, dialect);
-    return `${lateral}${base}${alias}${colAliases}`;
-  }
-  /**
-   * Formats the schema prefix for the function name.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Schema prefix (e.g., "schema.") or empty string.
-   * @internal
-   */
-  static formatSchema(fn, dialect) {
-    if (!fn.schema) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn.schema) : fn.schema;
-    return `${quoted}.`;
-  }
-  /**
-   * Formats function arguments into SQL syntax.
-   * @param fn - The function table node containing arguments.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns Comma-separated function arguments.
-   * @internal
-   */
-  static formatArgs(fn, ctx, dialect) {
-    return (fn.args || []).map((a) => {
-      if (ctx && dialect) {
-        return dialect.compileOperand(a, ctx);
-      }
-      return String(a);
-    }).join(", ");
-  }
-  /**
-   * Formats the base function call with WITH ORDINALITY if present.
-   * @param fn - The function table node.
-   * @param schemaPart - Formatted schema prefix.
-   * @param args - Formatted function arguments.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Base function call expression (e.g., "schema.func(args) WITH ORDINALITY").
-   * @internal
-   */
-  static formatBase(fn, schemaPart, args, dialect) {
-    const ordinality = fn.withOrdinality ? " WITH ORDINALITY" : "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn.name) : fn.name;
-    return `${schemaPart}${quoted}(${args})${ordinality}`;
-  }
-  /**
-   * Formats the LATERAL keyword if present.
-   * @param fn - The function table node.
-   * @returns "LATERAL " or empty string.
-   * @internal
-   */
-  static formatLateral(fn) {
-    return fn.lateral ? "LATERAL " : "";
-  }
-  /**
-   * Formats the table alias for the function table.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns " AS alias" or empty string.
-   * @internal
-   */
-  static formatAlias(fn, dialect) {
-    if (!fn.alias) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn.alias) : fn.alias;
-    return ` AS ${quoted}`;
-  }
-  /**
-   * Formats column aliases for the function table result columns.
-   * @param fn - The function table node containing column aliases.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns "(col1, col2, ...)" or empty string.
-   * @internal
-   */
-  static formatColumnAliases(fn, dialect) {
-    if (!fn.columnAliases || !fn.columnAliases.length) return "";
-    const aliases = fn.columnAliases.map((col) => dialect ? dialect.quoteIdentifier(col) : col).join(", ");
-    return `(${aliases})`;
-  }
-};
-
-// src/core/dialect/base/pagination-strategy.ts
-var StandardLimitOffsetPagination = class {
-  /**
-   * Compiles LIMIT/OFFSET pagination clause.
-   * @param limit - The maximum number of rows to return.
-   * @param offset - The number of rows to skip.
-   * @returns SQL pagination clause with LIMIT and/or OFFSET.
-   */
-  compilePagination(limit, offset) {
-    const parts = [];
-    if (limit !== void 0) parts.push(`LIMIT ${limit}`);
-    if (offset !== void 0) parts.push(`OFFSET ${offset}`);
-    return parts.length ? ` ${parts.join(" ")}` : "";
-  }
-};
-
-// src/core/dialect/base/cte-compiler.ts
-var CteCompiler = class {
-  /**
-   * Compiles CTEs (WITH clauses) including recursive CTEs.
-   * @param ast - The SELECT query AST containing CTE definitions.
-   * @param ctx - The compiler context for expression compilation.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @param compileSelectAst - Function to recursively compile SELECT query ASTs.
-   * @param normalizeSelectAst - Function to normalize SELECT query ASTs before compilation.
-   * @param stripTrailingSemicolon - Function to remove trailing semicolons from SQL.
-   * @returns SQL WITH clause string (e.g., "WITH cte_name AS (...) ") or empty string if no CTEs.
-   */
-  static compileCtes(ast, ctx, quoteIdentifier, compileSelectAst, normalizeSelectAst, stripTrailingSemicolon) {
-    if (!ast.ctes || ast.ctes.length === 0) return "";
-    const hasRecursive = ast.ctes.some((cte) => cte.recursive);
-    const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
-    const cteDefs = ast.ctes.map((cte) => {
-      const name = quoteIdentifier(cte.name);
-      const cols = cte.columns && cte.columns.length ? `(${cte.columns.map((c) => quoteIdentifier(c)).join(", ")})` : "";
-      const query = stripTrailingSemicolon(compileSelectAst(normalizeSelectAst(cte.query), ctx));
-      return `${name}${cols} AS (${query})`;
-    }).join(", ");
-    return `${prefix}${cteDefs} `;
-  }
-};
-
-// src/core/dialect/base/returning-strategy.ts
-var NoReturningStrategy = class {
-  /**
-   * Throws an error as RETURNING is not supported.
-   * @param returning - Columns to return (causes error if non-empty).
-   * @param _ctx - Compiler context (unused).
-   * @throws Error indicating RETURNING is not supported.
-   */
-  compileReturning(returning, _ctx) {
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  /**
-   * Formats column names for RETURNING clause.
-   * @param returning - Columns to format.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @returns Simple comma-separated column names.
-   */
-  formatReturningColumns(returning, quoteIdentifier) {
-    return returning.map((column) => {
-      const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : "";
-      const aliasPart = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${tablePart}${quoteIdentifier(column.name)}${aliasPart}`;
-    }).join(", ");
-  }
-};
-
-// src/core/dialect/base/join-compiler.ts
-var JoinCompiler = class {
-  /**
-   * Compiles all JOIN clauses from a SELECT query AST.
-   * @param ast - The SELECT query AST containing join definitions.
-   * @param ctx - The compiler context for expression compilation.
-   * @param compileFrom - Function to compile table sources (tables or subqueries).
-   * @param compileExpression - Function to compile join condition expressions.
-   * @returns SQL JOIN clauses (e.g., " LEFT JOIN table ON condition") or empty string if no joins.
-   */
-  static compileJoins(ast, ctx, compileFrom, compileExpression) {
-    if (!ast.joins || ast.joins.length === 0) return "";
-    const parts = ast.joins.map((j) => {
-      const table = compileFrom(j.table, ctx);
-      const cond = compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    });
-    return ` ${parts.join(" ")}`;
-  }
-};
-
-// src/core/dialect/base/groupby-compiler.ts
-var GroupByCompiler = class {
-  /**
-   * Compiles GROUP BY clause from a SELECT query AST.
-   * @param ast - The SELECT query AST containing grouping columns.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @returns SQL GROUP BY clause (e.g., " GROUP BY table.col1, table.col2") or empty string if no grouping.
-   */
-  static compileGroupBy(ast, quoteIdentifier) {
-    if (!ast.groupBy || ast.groupBy.length === 0) return "";
-    const cols = ast.groupBy.map((c) => `${quoteIdentifier(c.table)}.${quoteIdentifier(c.name)}`).join(", ");
-    return ` GROUP BY ${cols}`;
-  }
-};
-
-// src/core/dialect/base/orderby-compiler.ts
-var OrderByCompiler = class {
-  /**
-   * Compiles ORDER BY clause from a SELECT query AST.
-   * @param ast - The SELECT query AST containing sort specifications.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @returns SQL ORDER BY clause (e.g., " ORDER BY table.col1 ASC, table.col2 DESC") or empty string if no ordering.
-   */
-  static compileOrderBy(ast, quoteIdentifier) {
-    if (!ast.orderBy || ast.orderBy.length === 0) return "";
-    const parts = ast.orderBy.map((o) => `${quoteIdentifier(o.column.table)}.${quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
-    return ` ORDER BY ${parts}`;
-  }
-};
-
-// src/core/dialect/base/sql-dialect.ts
-var SqlDialectBase = class extends Dialect {
-  constructor() {
-    super(...arguments);
-    this.paginationStrategy = new StandardLimitOffsetPagination();
-    this.returningStrategy = new NoReturningStrategy();
-  }
-  compileSelectAst(ast, ctx) {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    const ctes = CteCompiler.compileCtes(
-      ast,
-      ctx,
-      this.quoteIdentifier.bind(this),
-      this.compileSelectAst.bind(this),
-      this.normalizeSelectAst?.bind(this) ?? ((a) => a),
-      this.stripTrailingSemicolon.bind(this)
-    );
-    const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
-    if (!hasSetOps) {
-      return `${ctes}${baseSelect}`;
-    }
-    return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
-  }
-  compileSelectWithSetOps(ast, baseSelect, ctes, ctx) {
-    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = OrderByCompiler.compileOrderBy(ast, this.quoteIdentifier.bind(this));
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
-  }
-  compileInsertAst(ast, ctx) {
-    const table = this.compileTableName(ast.into);
-    const columnList = this.compileInsertColumnList(ast.columns);
-    const values = this.compileInsertValues(ast.values, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
-  }
-  compileReturning(returning, ctx) {
-    return this.returningStrategy.compileReturning(returning, ctx);
-  }
-  compileInsertColumnList(columns) {
-    return columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
-  }
-  compileInsertValues(values, ctx) {
-    return values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-  }
-  compileSelectCore(ast, ctx) {
-    const columns = this.compileSelectColumns(ast, ctx);
-    const from = this.compileFrom(ast.from, ctx);
-    const joins = JoinCompiler.compileJoins(ast, ctx, this.compileFrom.bind(this), this.compileExpression.bind(this));
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = GroupByCompiler.compileGroupBy(ast, this.quoteIdentifier.bind(this));
-    const having = this.compileHaving(ast, ctx);
-    const orderBy = OrderByCompiler.compileOrderBy(ast, this.quoteIdentifier.bind(this));
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
-  }
-  compileUpdateAst(ast, ctx) {
-    const table = this.compileTableName(ast.table);
-    const assignments = this.compileUpdateAssignments(ast.set, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
-  }
-  compileUpdateAssignments(assignments, ctx) {
-    return assignments.map((assignment) => {
-      const col = assignment.column;
-      const target = this.quoteIdentifier(col.name);
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
-  }
-  compileDeleteAst(ast, ctx) {
-    const table = this.compileTableName(ast.from);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning}`;
-  }
-  formatReturningColumns(returning) {
-    return this.returningStrategy.formatReturningColumns(returning, this.quoteIdentifier.bind(this));
-  }
-  compileDistinct(ast) {
-    return ast.distinct ? "DISTINCT " : "";
-  }
-  compileSelectColumns(ast, ctx) {
-    return ast.columns.map((c) => {
-      const expr = this.compileOperand(c, ctx);
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(", ");
-  }
-  compileFrom(ast, ctx) {
-    const tableSource = ast;
-    if (tableSource.type === "FunctionTable") {
-      return this.compileFunctionTable(tableSource, ctx);
-    }
-    if (tableSource.type === "DerivedTable") {
-      return this.compileDerivedTable(tableSource, ctx);
-    }
-    return this.compileTableSource(tableSource);
-  }
-  compileFunctionTable(fn, ctx) {
-    return FunctionTableFormatter.format(fn, ctx, this);
-  }
-  compileDerivedTable(table, ctx) {
-    if (!table.alias) {
-      throw new Error("Derived tables must have an alias.");
-    }
-    const subquery = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
-    const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-    return `(${subquery}) AS ${this.quoteIdentifier(table.alias)}${columns}`;
-  }
-  compileTableSource(table) {
-    if (table.type === "FunctionTable") {
-      return this.compileFunctionTable(table);
-    }
-    if (table.type === "DerivedTable") {
-      return this.compileDerivedTable(table);
-    }
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
-  }
-  compileTableName(table) {
-    if (table.schema) {
-      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
-    }
-    return this.quoteIdentifier(table.name);
-  }
-  compileHaving(ast, ctx) {
-    if (!ast.having) return "";
-    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
-  }
-  stripTrailingSemicolon(sql) {
-    return sql.trim().replace(/;$/, "");
-  }
-  wrapSetOperand(sql) {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
-  }
-};
-
-// src/core/dialect/postgres/functions.ts
-var PostgresFunctionStrategy = class extends StandardFunctionStrategy {
-  constructor() {
-    super();
-    this.registerOverrides();
-  }
-  registerOverrides() {
-    this.add("UTC_NOW", () => `(NOW() AT TIME ZONE 'UTC')`);
-    this.add("UNIX_TIMESTAMP", () => `EXTRACT(EPOCH FROM NOW())::INTEGER`);
-    this.add("FROM_UNIXTIME", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("FROM_UNIXTIME expects 1 argument");
-      return `to_timestamp(${compiledArgs[0]})`;
-    });
-    this.add("EXTRACT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("EXTRACT expects 2 arguments (part, date)");
-      const [part, date] = compiledArgs;
-      const partClean = part.replace(/['"]/g, "");
-      return `EXTRACT(${partClean} FROM ${date})`;
-    });
-    this.add("YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("YEAR expects 1 argument");
-      return `EXTRACT(YEAR FROM ${compiledArgs[0]})`;
-    });
-    this.add("MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("MONTH expects 1 argument");
-      return `EXTRACT(MONTH FROM ${compiledArgs[0]})`;
-    });
-    this.add("DAY", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY expects 1 argument");
-      return `EXTRACT(DAY FROM ${compiledArgs[0]})`;
-    });
-    this.add("DATE_ADD", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_ADD expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toLowerCase();
-      return `(${date} + (${interval} || ' ${unitClean}')::INTERVAL)`;
-    });
-    this.add("DATE_SUB", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_SUB expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toLowerCase();
-      return `(${date} - (${interval} || ' ${unitClean}')::INTERVAL)`;
-    });
-    this.add("DATE_DIFF", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_DIFF expects 2 arguments");
-      const [date1, date2] = compiledArgs;
-      return `(${date1}::DATE - ${date2}::DATE)`;
-    });
-    this.add("DATE_FORMAT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_FORMAT expects 2 arguments");
-      const [date, format] = compiledArgs;
-      return `TO_CHAR(${date}, ${format})`;
-    });
-    this.add("END_OF_MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("END_OF_MONTH expects 1 argument");
-      return `(date_trunc('month', ${compiledArgs[0]}) + interval '1 month' - interval '1 day')::DATE`;
-    });
-    this.add("DAY_OF_WEEK", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY_OF_WEEK expects 1 argument");
-      return `EXTRACT(DOW FROM ${compiledArgs[0]})`;
-    });
-    this.add("WEEK_OF_YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("WEEK_OF_YEAR expects 1 argument");
-      return `EXTRACT(WEEK FROM ${compiledArgs[0]})`;
-    });
-    this.add("DATE_TRUNC", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_TRUNC expects 2 arguments (part, date)");
-      const [, date] = compiledArgs;
-      const partArg = node.args[0];
-      const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
-      return `DATE_TRUNC('${partClean}', ${date})`;
-    });
-    this.add("GROUP_CONCAT", (ctx) => {
-      const arg = ctx.compiledArgs[0];
-      const orderClause = this.buildOrderByExpression(ctx);
-      const orderSegment = orderClause ? ` ${orderClause}` : "";
-      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-      const separator = ctx.compileOperand(separatorOperand);
-      return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
-    });
-  }
-};
-
-// src/core/dialect/postgres/index.ts
-var PostgresDialect = class extends SqlDialectBase {
-  /**
-   * Creates a new PostgresDialect instance
-   */
-  constructor() {
-    super(new PostgresFunctionStrategy());
-    this.dialect = "postgres";
-  }
-  /**
-   * Quotes an identifier using PostgreSQL double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id) {
-    return `"${id}"`;
-  }
-  /**
-   * Compiles JSON path expression using PostgreSQL syntax
-   * @param node - JSON path node
-   * @returns PostgreSQL JSON path expression
-   */
-  compileJsonPath(node) {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${col}->>'${node.path}'`;
-  }
-  compileReturning(returning, ctx) {
-    if (!returning || returning.length === 0) return "";
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-  supportsReturning() {
-    return true;
-  }
-};
-
-// src/core/dialect/mysql/functions.ts
-var MysqlFunctionStrategy = class extends StandardFunctionStrategy {
-  constructor() {
-    super();
-    this.registerOverrides();
-  }
-  registerOverrides() {
-    this.add("NOW", () => `NOW()`);
-    this.add("CURRENT_DATE", () => `CURDATE()`);
-    this.add("CURRENT_TIME", () => `CURTIME()`);
-    this.add("UTC_NOW", () => `UTC_TIMESTAMP()`);
-    this.add("EXTRACT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("EXTRACT expects 2 arguments (part, date)");
-      const [part, date] = compiledArgs;
-      const partClean = part.replace(/['"]/g, "");
-      return `EXTRACT(${partClean} FROM ${date})`;
-    });
-    this.add("YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("YEAR expects 1 argument");
-      return `YEAR(${compiledArgs[0]})`;
-    });
-    this.add("MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("MONTH expects 1 argument");
-      return `MONTH(${compiledArgs[0]})`;
-    });
-    this.add("DAY", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY expects 1 argument");
-      return `DAY(${compiledArgs[0]})`;
-    });
-    this.add("DATE_ADD", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_ADD expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toUpperCase();
-      return `DATE_ADD(${date}, INTERVAL ${interval} ${unitClean})`;
-    });
-    this.add("DATE_SUB", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_SUB expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toUpperCase();
-      return `DATE_SUB(${date}, INTERVAL ${interval} ${unitClean})`;
-    });
-    this.add("DATE_DIFF", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_DIFF expects 2 arguments");
-      const [date1, date2] = compiledArgs;
-      return `DATEDIFF(${date1}, ${date2})`;
-    });
-    this.add("DATE_FORMAT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_FORMAT expects 2 arguments");
-      const [date, format] = compiledArgs;
-      return `DATE_FORMAT(${date}, ${format})`;
-    });
-    this.add("END_OF_MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("END_OF_MONTH expects 1 argument");
-      return `LAST_DAY(${compiledArgs[0]})`;
-    });
-    this.add("DAY_OF_WEEK", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY_OF_WEEK expects 1 argument");
-      return `DAYOFWEEK(${compiledArgs[0]})`;
-    });
-    this.add("WEEK_OF_YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("WEEK_OF_YEAR expects 1 argument");
-      return `WEEKOFYEAR(${compiledArgs[0]})`;
-    });
-    this.add("DATE_TRUNC", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_TRUNC expects 2 arguments (part, date)");
-      const [, date] = compiledArgs;
-      const partArg = node.args[0];
-      const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
-      if (partClean === "year") {
-        return `DATE_FORMAT(${date}, '%Y-01-01')`;
-      } else if (partClean === "month") {
-        return `DATE_FORMAT(${date}, '%Y-%m-01')`;
-      } else if (partClean === "day") {
-        return `DATE(${date})`;
-      }
-      return `DATE(${date})`;
-    });
-  }
-};
-
-// src/core/dialect/mysql/index.ts
-var MySqlDialect = class extends SqlDialectBase {
-  /**
-   * Creates a new MySqlDialect instance
-   */
-  constructor() {
-    super(new MysqlFunctionStrategy());
-    this.dialect = "mysql";
-  }
-  /**
-   * Quotes an identifier using MySQL backtick syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id) {
-    return `\`${id}\``;
-  }
-  /**
-   * Compiles JSON path expression using MySQL syntax
-   * @param node - JSON path node
-   * @returns MySQL JSON path expression
-   */
-  compileJsonPath(node) {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${col}->'${node.path}'`;
-  }
-};
-
-// src/core/dialect/sqlite/functions.ts
-var SqliteFunctionStrategy = class extends StandardFunctionStrategy {
-  constructor() {
-    super();
-    this.registerOverrides();
-  }
-  registerOverrides() {
-    this.add("NOW", () => `datetime('now', 'localtime')`);
-    this.add("CURRENT_DATE", () => `date('now', 'localtime')`);
-    this.add("CURRENT_TIME", () => `time('now', 'localtime')`);
-    this.add("UTC_NOW", () => `datetime('now')`);
-    this.add("EXTRACT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("EXTRACT expects 2 arguments (part, date)");
-      const [part, date] = compiledArgs;
-      const partUpper = part.replace(/['"]/g, "").toUpperCase();
-      const formatMap = {
-        "YEAR": "%Y",
-        "MONTH": "%m",
-        "DAY": "%d",
-        "HOUR": "%H",
-        "MINUTE": "%M",
-        "SECOND": "%S",
-        "DOW": "%w",
-        "WEEK": "%W"
-      };
-      const format = formatMap[partUpper] || "%Y";
-      return `CAST(strftime('${format}', ${date}) AS INTEGER)`;
-    });
-    this.add("YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("YEAR expects 1 argument");
-      return `CAST(strftime('%Y', ${compiledArgs[0]}) AS INTEGER)`;
-    });
-    this.add("MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("MONTH expects 1 argument");
-      return `CAST(strftime('%m', ${compiledArgs[0]}) AS INTEGER)`;
-    });
-    this.add("DAY", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY expects 1 argument");
-      return `CAST(strftime('%d', ${compiledArgs[0]}) AS INTEGER)`;
-    });
-    this.add("DATE_ADD", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_ADD expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toLowerCase();
-      return `datetime(${date}, '+' || ${interval} || ' ${unitClean}')`;
-    });
-    this.add("DATE_SUB", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_SUB expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toLowerCase();
-      return `datetime(${date}, '-' || ${interval} || ' ${unitClean}')`;
-    });
-    this.add("DATE_DIFF", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_DIFF expects 2 arguments");
-      const [date1, date2] = compiledArgs;
-      return `CAST(julianday(${date1}) - julianday(${date2}) AS INTEGER)`;
-    });
-    this.add("DATE_FORMAT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_FORMAT expects 2 arguments");
-      const [date, format] = compiledArgs;
-      return `strftime(${format}, ${date})`;
-    });
-    this.add("UNIX_TIMESTAMP", () => `CAST(strftime('%s', 'now') AS INTEGER)`);
-    this.add("FROM_UNIXTIME", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("FROM_UNIXTIME expects 1 argument");
-      return `datetime(${compiledArgs[0]}, 'unixepoch')`;
-    });
-    this.add("END_OF_MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("END_OF_MONTH expects 1 argument");
-      return `date(${compiledArgs[0]}, 'start of month', '+1 month', '-1 day')`;
-    });
-    this.add("DAY_OF_WEEK", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY_OF_WEEK expects 1 argument");
-      return `CAST(strftime('%w', ${compiledArgs[0]}) AS INTEGER)`;
-    });
-    this.add("WEEK_OF_YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("WEEK_OF_YEAR expects 1 argument");
-      return `CAST(strftime('%W', ${compiledArgs[0]}) AS INTEGER)`;
-    });
-    this.add("DATE_TRUNC", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_TRUNC expects 2 arguments (part, date)");
-      const [, date] = compiledArgs;
-      const partArg = node.args[0];
-      const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
-      if (partClean === "year") {
-        return `date(${date}, 'start of year')`;
-      } else if (partClean === "month") {
-        return `date(${date}, 'start of month')`;
-      } else if (partClean === "day") {
-        return `date(${date})`;
-      }
-      return `date(${date}, 'start of ${partClean}')`;
-    });
-    this.add("GROUP_CONCAT", (ctx) => {
-      const arg = ctx.compiledArgs[0];
-      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-      const separator = ctx.compileOperand(separatorOperand);
-      return `GROUP_CONCAT(${arg}, ${separator})`;
-    });
-  }
-};
-
-// src/core/dialect/sqlite/index.ts
-var SqliteDialect = class extends SqlDialectBase {
-  /**
-   * Creates a new SqliteDialect instance
-   */
-  constructor() {
-    super(new SqliteFunctionStrategy());
-    this.dialect = "sqlite";
-  }
-  /**
-   * Quotes an identifier using SQLite double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id) {
-    return `"${id}"`;
-  }
-  /**
-   * Compiles JSON path expression using SQLite syntax
-   * @param node - JSON path node
-   * @returns SQLite JSON path expression
-   */
-  compileJsonPath(node) {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `json_extract(${col}, '${node.path}')`;
-  }
-  compileReturning(returning, ctx) {
-    if (!returning || returning.length === 0) return "";
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-  formatReturningColumns(returning) {
-    return returning.map((column) => {
-      const alias = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : "";
-      return `${this.quoteIdentifier(column.name)}${alias}`;
-    }).join(", ");
-  }
-  supportsReturning() {
-    return true;
-  }
-};
-
-// src/core/dialect/mssql/functions.ts
-var MssqlFunctionStrategy = class extends StandardFunctionStrategy {
-  constructor() {
-    super();
-    this.registerOverrides();
-  }
-  registerOverrides() {
-    this.add("NOW", () => `GETDATE()`);
-    this.add("CURRENT_DATE", () => `CAST(GETDATE() AS DATE)`);
-    this.add("CURRENT_TIME", () => `CAST(GETDATE() AS TIME)`);
-    this.add("UTC_NOW", () => `GETUTCDATE()`);
-    this.add("EXTRACT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("EXTRACT expects 2 arguments (part, date)");
-      const [part, date] = compiledArgs;
-      const partClean = part.replace(/['"]/g, "").toLowerCase();
-      return `DATEPART(${partClean}, ${date})`;
-    });
-    this.add("YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("YEAR expects 1 argument");
-      return `YEAR(${compiledArgs[0]})`;
-    });
-    this.add("MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("MONTH expects 1 argument");
-      return `MONTH(${compiledArgs[0]})`;
-    });
-    this.add("DAY", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY expects 1 argument");
-      return `DAY(${compiledArgs[0]})`;
-    });
-    this.add("DATE_ADD", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_ADD expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toLowerCase();
-      return `DATEADD(${unitClean}, ${interval}, ${date})`;
-    });
-    this.add("DATE_SUB", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 3) throw new Error("DATE_SUB expects 3 arguments (date, interval, unit)");
-      const [date, interval] = compiledArgs;
-      const unitArg = node.args[2];
-      const unitClean = String(unitArg.value).replace(/['"]/g, "").toLowerCase();
-      return `DATEADD(${unitClean}, -${interval}, ${date})`;
-    });
-    this.add("DATE_DIFF", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_DIFF expects 2 arguments");
-      const [date1, date2] = compiledArgs;
-      return `DATEDIFF(day, ${date2}, ${date1})`;
-    });
-    this.add("DATE_FORMAT", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_FORMAT expects 2 arguments");
-      const [date, format] = compiledArgs;
-      return `FORMAT(${date}, ${format})`;
-    });
-    this.add("UNIX_TIMESTAMP", () => `DATEDIFF(SECOND, '1970-01-01', GETUTCDATE())`);
-    this.add("FROM_UNIXTIME", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("FROM_UNIXTIME expects 1 argument");
-      return `DATEADD(SECOND, ${compiledArgs[0]}, '1970-01-01')`;
-    });
-    this.add("END_OF_MONTH", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("END_OF_MONTH expects 1 argument");
-      return `EOMONTH(${compiledArgs[0]})`;
-    });
-    this.add("DAY_OF_WEEK", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("DAY_OF_WEEK expects 1 argument");
-      return `DATEPART(dw, ${compiledArgs[0]})`;
-    });
-    this.add("WEEK_OF_YEAR", ({ compiledArgs }) => {
-      if (compiledArgs.length !== 1) throw new Error("WEEK_OF_YEAR expects 1 argument");
-      return `DATEPART(wk, ${compiledArgs[0]})`;
-    });
-    this.add("DATE_TRUNC", ({ node, compiledArgs }) => {
-      if (compiledArgs.length !== 2) throw new Error("DATE_TRUNC expects 2 arguments (part, date)");
-      const [, date] = compiledArgs;
-      const partArg = node.args[0];
-      const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
-      return `DATETRUNC(${partClean}, ${date})`;
-    });
-    this.add("GROUP_CONCAT", (ctx) => {
-      const arg = ctx.compiledArgs[0];
-      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-      const separator = ctx.compileOperand(separatorOperand);
-      const orderClause = this.buildOrderByExpression(ctx);
-      const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : "";
-      return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
-    });
-  }
-};
-
-// src/core/dialect/mssql/index.ts
-var SqlServerDialect = class extends Dialect {
-  /**
-   * Creates a new SqlServerDialect instance
-   */
-  constructor() {
-    super(new MssqlFunctionStrategy());
-    this.dialect = "mssql";
-  }
-  /**
-   * Quotes an identifier using SQL Server bracket syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id) {
-    return `[${id}]`;
-  }
-  /**
-   * Compiles JSON path expression using SQL Server syntax
-   * @param node - JSON path node
-   * @returns SQL Server JSON path expression
-   */
-  compileJsonPath(node) {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `JSON_VALUE(${col}, '${node.path}')`;
-  }
-  /**
-   * Formats parameter placeholders using SQL Server named parameter syntax
-   * @param index - Parameter index
-   * @returns Named parameter placeholder
-   */
-  formatPlaceholder(index) {
-    return `@p${index}`;
-  }
-  /**
-   * Compiles SELECT query AST to SQL Server SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL Server SQL string
-   */
-  compileSelectAst(ast, ctx) {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    const ctes = this.compileCtes(ast, ctx);
-    const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
-    if (!hasSetOps) {
-      return `${ctes}${baseSelect}`;
-    }
-    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = this.compileOrderBy(ast);
-    const pagination = this.compilePagination(ast, orderBy);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    const tail = pagination || orderBy;
-    return `${ctes}${combined}${tail}`;
-  }
-  compileInsertAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
-    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-  compileUpdateAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map((assignment) => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
-  }
-  compileDeleteAst(ast, ctx) {
-    if (ast.from.type !== "Table") {
-      throw new Error("DELETE only supports base tables in the MSSQL dialect.");
-    }
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
-  }
-  compileSelectCore(ast, ctx) {
-    const columns = ast.columns.map((c) => {
-      let expr = "";
-      if (c.type === "Function") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "Column") {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === "ScalarSubquery") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "WindowFunction") {
-        expr = this.compileOperand(c, ctx);
-      }
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(", ");
-    const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = this.compileTableSource(ast.from, ctx);
-    const joins = ast.joins.map((j) => {
-      const table = this.compileTableSource(j.table, ctx);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(" ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
-    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = this.compileOrderBy(ast);
-    const pagination = this.compilePagination(ast, orderBy);
-    if (pagination) {
-      return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${pagination}`;
-    }
-    return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}`;
-  }
-  compileOrderBy(ast) {
-    if (!ast.orderBy || ast.orderBy.length === 0) return "";
-    return " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
-  }
-  compilePagination(ast, orderBy) {
-    const hasLimit = ast.limit !== void 0;
-    const hasOffset = ast.offset !== void 0;
-    if (!hasLimit && !hasOffset) return "";
-    const off = ast.offset ?? 0;
-    const orderClause = orderBy || " ORDER BY (SELECT NULL)";
-    let pagination = `${orderClause} OFFSET ${off} ROWS`;
-    if (hasLimit) {
-      pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
-    }
-    return pagination;
-  }
-  compileTableSource(table, ctx) {
-    if (table.type === "FunctionTable") {
-      return FunctionTableFormatter.format(table, ctx, this);
-    }
-    if (table.type === "DerivedTable") {
-      return this.compileDerivedTable(table, ctx);
-    }
-    const base = table.schema ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}` : this.quoteIdentifier(table.name);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
-  }
-  compileDerivedTable(table, ctx) {
-    const sub = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
-    const cols = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-    return `(${sub}) AS ${this.quoteIdentifier(table.alias)}${cols}`;
-  }
-  compileCtes(ast, ctx) {
-    if (!ast.ctes || ast.ctes.length === 0) return "";
-    const defs = ast.ctes.map((cte) => {
-      const name = this.quoteIdentifier(cte.name);
-      const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, "");
-      return `${name}${cols} AS (${query})`;
-    }).join(", ");
-    return `WITH ${defs} `;
-  }
-  wrapSetOperand(sql) {
-    const trimmed = sql.trim().replace(/;$/, "");
-    return `(${trimmed})`;
-  }
-};
-
-// src/core/dialect/dialect-factory.ts
-var DialectFactory = class {
-  static {
-    this.registry = /* @__PURE__ */ new Map();
-  }
-  static {
-    this.defaultsInitialized = false;
-  }
-  static ensureDefaults() {
-    if (this.defaultsInitialized) return;
-    this.defaultsInitialized = true;
-    if (!this.registry.has("postgres")) {
-      this.registry.set("postgres", () => new PostgresDialect());
-    }
-    if (!this.registry.has("mysql")) {
-      this.registry.set("mysql", () => new MySqlDialect());
-    }
-    if (!this.registry.has("sqlite")) {
-      this.registry.set("sqlite", () => new SqliteDialect());
-    }
-    if (!this.registry.has("mssql")) {
-      this.registry.set("mssql", () => new SqlServerDialect());
-    }
-  }
-  /**
-   * Register (or override) a dialect factory for a key.
-   *
-   * Examples:
-   *   DialectFactory.register('sqlite', () => new SqliteDialect());
-   *   DialectFactory.register('my-tenant-dialect', () => new CustomDialect());
-   */
-  static register(key, factory) {
-    this.registry.set(key, factory);
-  }
-  /**
-   * Resolve a key into a Dialect instance.
-   * Throws if the key is not registered.
-   */
-  static create(key) {
-    this.ensureDefaults();
-    const factory = this.registry.get(key);
-    if (!factory) {
-      throw new Error(
-        `Dialect "${String(
-          key
-        )}" is not registered. Use DialectFactory.register(...) to register it.`
-      );
-    }
-    return factory();
-  }
-  /**
-   * Clear all registrations (mainly for tests).
-   * Built-ins will be re-registered lazily on the next create().
-   */
-  static clear() {
-    this.registry.clear();
-    this.defaultsInitialized = false;
-  }
-};
-var resolveDialectInput = (dialect) => {
-  if (typeof dialect === "string") {
-    return DialectFactory.create(dialect);
-  }
-  return dialect;
-};
-
-// src/query-builder/select-query-state.ts
-var SelectQueryState = class _SelectQueryState {
-  /**
-   * Creates a new SelectQueryState instance
-   * @param table - Table definition
-   * @param ast - Optional existing AST
-   */
-  constructor(table, ast) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: "SelectQuery",
-      from: { type: "Table", name: table.name },
-      columns: [],
-      joins: []
-    };
-  }
-  /**
-   * Creates a new SelectQueryState with updated AST
-   * @param nextAst - Updated AST
-   * @returns New SelectQueryState instance
-   */
-  clone(nextAst) {
-    return new _SelectQueryState(this.table, nextAst);
-  }
-  /**
-   * Adds columns to the query
-   * @param newCols - Columns to add
-   * @returns New SelectQueryState with added columns
-   */
-  withColumns(newCols) {
-    return this.clone({
-      ...this.ast,
-      columns: [...this.ast.columns ?? [], ...newCols]
-    });
-  }
-  /**
-   * Adds a join to the query
-   * @param join - Join node to add
-   * @returns New SelectQueryState with added join
-   */
-  withJoin(join) {
-    return this.clone({
-      ...this.ast,
-      joins: [...this.ast.joins ?? [], join]
-    });
-  }
-  /**
-   * Replaces the FROM clause.
-   * @param from - Table source for the FROM clause
-   * @returns New SelectQueryState with updated FROM
-   */
-  withFrom(from) {
-    return this.clone({
-      ...this.ast,
-      from
-    });
-  }
-  /**
-   * Adds a WHERE clause to the query
-   * @param predicate - WHERE predicate expression
-   * @returns New SelectQueryState with WHERE clause
-   */
-  withWhere(predicate) {
-    return this.clone({
-      ...this.ast,
-      where: predicate
-    });
-  }
-  /**
-   * Adds a HAVING clause to the query
-   * @param predicate - HAVING predicate expression
-   * @returns New SelectQueryState with HAVING clause
-   */
-  withHaving(predicate) {
-    return this.clone({
-      ...this.ast,
-      having: predicate
-    });
-  }
-  /**
-   * Adds GROUP BY columns to the query
-   * @param columns - Columns to group by
-   * @returns New SelectQueryState with GROUP BY clause
-   */
-  withGroupBy(columns) {
-    return this.clone({
-      ...this.ast,
-      groupBy: [...this.ast.groupBy ?? [], ...columns]
-    });
-  }
-  /**
-   * Adds ORDER BY clauses to the query
-   * @param orderBy - ORDER BY nodes
-   * @returns New SelectQueryState with ORDER BY clause
-   */
-  withOrderBy(orderBy) {
-    return this.clone({
-      ...this.ast,
-      orderBy: [...this.ast.orderBy ?? [], ...orderBy]
-    });
-  }
-  /**
-   * Adds DISTINCT columns to the query
-   * @param columns - Columns to make distinct
-   * @returns New SelectQueryState with DISTINCT clause
-   */
-  withDistinct(columns) {
-    return this.clone({
-      ...this.ast,
-      distinct: [...this.ast.distinct ?? [], ...columns]
-    });
-  }
-  /**
-   * Adds a LIMIT clause to the query
-   * @param limit - Maximum number of rows to return
-   * @returns New SelectQueryState with LIMIT clause
-   */
-  withLimit(limit) {
-    return this.clone({
-      ...this.ast,
-      limit
-    });
-  }
-  /**
-   * Adds an OFFSET clause to the query
-   * @param offset - Number of rows to skip
-   * @returns New SelectQueryState with OFFSET clause
-   */
-  withOffset(offset) {
-    return this.clone({
-      ...this.ast,
-      offset
-    });
-  }
-  /**
-   * Adds a Common Table Expression (CTE) to the query
-   * @param cte - CTE node to add
-   * @returns New SelectQueryState with CTE
-   */
-  withCte(cte) {
-    return this.clone({
-      ...this.ast,
-      ctes: [...this.ast.ctes ?? [], cte]
-    });
-  }
-  /**
-   * Adds a set operation (UNION/INTERSECT/EXCEPT) to the query
-   * @param op - Set operation node to add
-   * @returns New SelectQueryState with set operation
-   */
-  withSetOperation(op) {
-    return this.clone({
-      ...this.ast,
-      setOps: [...this.ast.setOps ?? [], op]
-    });
-  }
-};
-
-// src/core/ast/join-node.ts
-var createJoinNode = (kind, tableName, condition, relationName) => ({
-  type: "Join",
-  kind,
-  table: typeof tableName === "string" ? { type: "Table", name: tableName } : tableName,
-  condition,
-  meta: relationName ? { relationName } : void 0
-});
-
-// src/query-builder/hydration-manager.ts
-var HydrationManager = class _HydrationManager {
-  /**
-   * Creates a new HydrationManager instance
-   * @param table - Table definition
-   * @param planner - Hydration planner
-   */
-  constructor(table, planner) {
-    this.table = table;
-    this.planner = planner;
-  }
-  /**
-   * Creates a new HydrationManager with updated planner
-   * @param nextPlanner - Updated hydration planner
-   * @returns New HydrationManager instance
-   */
-  clone(nextPlanner) {
-    return new _HydrationManager(this.table, nextPlanner);
-  }
-  /**
-   * Handles column selection for hydration planning
-   * @param state - Current query state
-   * @param newColumns - Newly selected columns
-   * @returns Updated HydrationManager with captured columns
-   */
-  onColumnsSelected(state, newColumns) {
-    const updated = this.planner.captureRootColumns(newColumns);
-    return this.clone(updated);
-  }
-  /**
-   * Handles relation inclusion for hydration planning
-   * @param state - Current query state
-   * @param relation - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for the relation
-   * @param targetColumns - Target columns to include
-   * @returns Updated HydrationManager with included relation
-   */
-  onRelationIncluded(state, relation, relationName, aliasPrefix, targetColumns, pivot) {
-    const withRoots = this.planner.captureRootColumns(state.ast.columns);
-    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
-    return this.clone(next);
-  }
-  /**
-   * Applies hydration plan to the AST
-   * @param ast - Query AST to modify
-   * @returns AST with hydration metadata
-   */
-  applyToAst(ast) {
-    if (ast.setOps && ast.setOps.length > 0) {
-      return ast;
-    }
-    const plan = this.planner.getPlan();
-    if (!plan) return ast;
-    const needsPaginationGuard = this.requiresParentPagination(ast, plan);
-    const rewritten = needsPaginationGuard ? this.wrapForParentPagination(ast, plan) : ast;
-    return this.attachHydrationMeta(rewritten, plan);
-  }
-  /**
-   * Gets the current hydration plan
-   * @returns Hydration plan or undefined if none exists
-   */
-  getPlan() {
-    return this.planner.getPlan();
-  }
-  /**
-   * Attaches hydration metadata to a query AST node.
-   */
-  attachHydrationMeta(ast, plan) {
-    return {
-      ...ast,
-      meta: {
-        ...ast.meta || {},
-        hydration: plan
-      }
-    };
-  }
-  /**
-   * Determines whether the query needs pagination rewriting to keep LIMIT/OFFSET
-   * applied to parent rows when eager-loading multiplicative relations.
-   */
-  requiresParentPagination(ast, plan) {
-    const hasPagination = ast.limit !== void 0 || ast.offset !== void 0;
-    return hasPagination && this.hasMultiplyingRelations(plan);
-  }
-  hasMultiplyingRelations(plan) {
-    return plan.relations.some(
-      (rel) => rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany
-    );
-  }
-  /**
-   * Rewrites the query using CTEs so LIMIT/OFFSET target distinct parent rows
-   * instead of the joined result set.
-   *
-   * The strategy:
-   * - Hoist the original query (minus limit/offset) into a base CTE.
-   * - Select distinct parent ids from that base CTE with the original ordering and pagination.
-   * - Join the base CTE against the paged ids to retrieve the joined rows for just that page.
-   */
-  wrapForParentPagination(ast, plan) {
-    const projectionNames = this.getProjectionNames(ast.columns);
-    if (!projectionNames) {
-      return ast;
-    }
-    const projectionAliases = this.buildProjectionAliasMap(ast.columns);
-    const projectionSet = new Set(projectionNames);
-    const rootPkAlias = projectionAliases.get(`${plan.rootTable}.${plan.rootPrimaryKey}`) ?? plan.rootPrimaryKey;
-    const baseCteName = this.nextCteName(ast.ctes, "__metal_pagination_base");
-    const baseQuery = {
-      ...ast,
-      ctes: void 0,
-      limit: void 0,
-      offset: void 0,
-      orderBy: void 0,
-      meta: void 0
-    };
-    const baseCte = {
-      type: "CommonTableExpression",
-      name: baseCteName,
-      query: baseQuery,
-      recursive: false
-    };
-    const orderBy = this.mapOrderBy(ast.orderBy, plan, projectionAliases, baseCteName, projectionSet);
-    if (orderBy === null) {
-      return ast;
-    }
-    const pageCteName = this.nextCteName([...ast.ctes ?? [], baseCte], "__metal_pagination_page");
-    const pagingColumns = this.buildPagingColumns(rootPkAlias, orderBy, baseCteName);
-    const pageCte = {
-      type: "CommonTableExpression",
-      name: pageCteName,
-      query: {
-        type: "SelectQuery",
-        from: { type: "Table", name: baseCteName },
-        columns: pagingColumns,
-        joins: [],
-        distinct: [{ type: "Column", table: baseCteName, name: rootPkAlias }],
-        orderBy,
-        limit: ast.limit,
-        offset: ast.offset
-      },
-      recursive: false
-    };
-    const joinCondition = eq(
-      { type: "Column", table: baseCteName, name: rootPkAlias },
-      { type: "Column", table: pageCteName, name: rootPkAlias }
-    );
-    const outerColumns = projectionNames.map((name) => ({
-      type: "Column",
-      table: baseCteName,
-      name,
-      alias: name
-    }));
-    return {
-      type: "SelectQuery",
-      from: { type: "Table", name: baseCteName },
-      columns: outerColumns,
-      joins: [createJoinNode(JOIN_KINDS.INNER, pageCteName, joinCondition)],
-      orderBy,
-      ctes: [...ast.ctes ?? [], baseCte, pageCte]
-    };
-  }
-  nextCteName(existing, baseName) {
-    const names = new Set((existing ?? []).map((cte) => cte.name));
-    let candidate = baseName;
-    let suffix = 1;
-    while (names.has(candidate)) {
-      suffix += 1;
-      candidate = `${baseName}_${suffix}`;
-    }
-    return candidate;
-  }
-  getProjectionNames(columns) {
-    const names = [];
-    for (const col of columns) {
-      const alias = col.alias ?? col.name;
-      if (!alias) return void 0;
-      names.push(alias);
-    }
-    return names;
-  }
-  buildProjectionAliasMap(columns) {
-    const map = /* @__PURE__ */ new Map();
-    for (const col of columns) {
-      if (col.type !== "Column") continue;
-      const node = col;
-      const key = `${node.table}.${node.name}`;
-      map.set(key, node.alias ?? node.name);
-    }
-    return map;
-  }
-  mapOrderBy(orderBy, plan, projectionAliases, baseAlias, availableColumns) {
-    if (!orderBy || orderBy.length === 0) {
-      return void 0;
-    }
-    const mapped = [];
-    for (const ob of orderBy) {
-      if (ob.column.table !== plan.rootTable) {
-        return null;
-      }
-      const alias = projectionAliases.get(`${ob.column.table}.${ob.column.name}`) ?? ob.column.name;
-      if (!availableColumns.has(alias)) {
-        return null;
-      }
-      mapped.push({
-        type: "OrderBy",
-        column: { type: "Column", table: baseAlias, name: alias },
-        direction: ob.direction
-      });
-    }
-    return mapped;
-  }
-  buildPagingColumns(primaryKey, orderBy, tableAlias) {
-    const columns = [{ type: "Column", table: tableAlias, name: primaryKey, alias: primaryKey }];
-    if (!orderBy) return columns;
-    for (const ob of orderBy) {
-      if (!columns.some((col) => col.name === ob.column.name)) {
-        columns.push({
-          type: "Column",
-          table: tableAlias,
-          name: ob.column.name,
-          alias: ob.column.name
-        });
-      }
-    }
-    return columns;
-  }
-};
-
-// src/query-builder/relation-alias.ts
-var RELATION_SEPARATOR = "__";
-var makeRelationAlias = (relationName, columnName) => `${relationName}${RELATION_SEPARATOR}${columnName}`;
-var isRelationAlias = (alias) => !!alias && alias.includes(RELATION_SEPARATOR);
-
-// src/query-builder/relation-utils.ts
-var buildDefaultPivotColumns = (rel, pivotPk) => {
-  const excluded = /* @__PURE__ */ new Set([pivotPk, rel.pivotForeignKeyToRoot, rel.pivotForeignKeyToTarget]);
-  return Object.keys(rel.pivotTable.columns).filter((col) => !excluded.has(col));
-};
-
-// src/query-builder/hydration-planner.ts
-var findPrimaryKey = (table) => {
-  const pk = Object.values(table.columns).find((c) => c.primary);
-  return pk?.name || "id";
-};
-var HydrationPlanner = class _HydrationPlanner {
-  /**
-   * Creates a new HydrationPlanner instance
-   * @param table - Table definition
-   * @param plan - Optional existing hydration plan
-   */
-  constructor(table, plan) {
-    this.table = table;
-    this.plan = plan;
-  }
-  /**
-   * Captures root table columns for hydration planning
-   * @param columns - Columns to capture
-   * @returns Updated HydrationPlanner with captured columns
-   */
-  captureRootColumns(columns) {
-    const currentPlan = this.getPlanOrDefault();
-    const rootCols = new Set(currentPlan.rootColumns);
-    let changed = false;
-    columns.forEach((node) => {
-      if (node.type !== "Column") return;
-      if (node.table !== this.table.name) return;
-      const alias = node.alias || node.name;
-      if (isRelationAlias(alias)) return;
-      if (!rootCols.has(alias)) {
-        rootCols.add(alias);
-        changed = true;
-      }
-    });
-    if (!changed) return this;
-    return new _HydrationPlanner(this.table, {
-      ...currentPlan,
-      rootColumns: Array.from(rootCols)
-    });
-  }
-  /**
-   * Includes a relation in the hydration plan
-   * @param rel - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for relation columns
-   * @param columns - Columns to include from the relation
-   * @returns Updated HydrationPlanner with included relation
-   */
-  includeRelation(rel, relationName, aliasPrefix, columns, pivot) {
-    const currentPlan = this.getPlanOrDefault();
-    const relations = currentPlan.relations.filter((r) => r.name !== relationName);
-    relations.push(this.buildRelationPlan(rel, relationName, aliasPrefix, columns, pivot));
-    return new _HydrationPlanner(this.table, {
-      ...currentPlan,
-      relations
-    });
-  }
-  /**
-   * Gets the current hydration plan
-   * @returns Current hydration plan or undefined
-   */
-  getPlan() {
-    return this.plan;
-  }
-  /**
-   * Gets the current hydration plan or creates a default one
-   * @returns Current hydration plan or default plan
-   */
-  getPlanOrDefault() {
-    return this.plan ?? buildDefaultHydrationPlan(this.table);
-  }
-  /**
-   * Builds a relation plan for hydration
-   * @param rel - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for relation columns
-   * @param columns - Columns to include from the relation
-   * @returns Hydration relation plan
-   */
-  buildRelationPlan(rel, relationName, aliasPrefix, columns, pivot) {
-    switch (rel.type) {
-      case RelationKinds.HasMany:
-      case RelationKinds.HasOne: {
-        const localKey = rel.localKey || findPrimaryKey(this.table);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
-          targetTable: rel.target.name,
-          targetPrimaryKey: findPrimaryKey(rel.target),
-          foreignKey: rel.foreignKey,
-          localKey,
-          columns
-        };
-      }
-      case RelationKinds.BelongsTo: {
-        const localKey = rel.localKey || findPrimaryKey(rel.target);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
-          targetTable: rel.target.name,
-          targetPrimaryKey: findPrimaryKey(rel.target),
-          foreignKey: rel.foreignKey,
-          localKey,
-          columns
-        };
-      }
-      case RelationKinds.BelongsToMany: {
-        const many = rel;
-        const localKey = many.localKey || findPrimaryKey(this.table);
-        const targetPk = many.targetKey || findPrimaryKey(many.target);
-        const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
-        const pivotAliasPrefix = pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
-        const pivotColumns = pivot?.columns ?? many.defaultPivotColumns ?? buildDefaultPivotColumns(many, pivotPk);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
-          targetTable: many.target.name,
-          targetPrimaryKey: targetPk,
-          foreignKey: many.pivotForeignKeyToRoot,
-          localKey,
-          columns,
-          pivot: {
-            table: many.pivotTable.name,
-            primaryKey: pivotPk,
-            aliasPrefix: pivotAliasPrefix,
-            columns: pivotColumns
-          }
-        };
-      }
-    }
-  }
-};
-var buildDefaultHydrationPlan = (table) => ({
-  rootTable: table.name,
-  rootPrimaryKey: findPrimaryKey(table),
-  rootColumns: [],
-  relations: []
-});
-
-// src/query-builder/raw-column-parser.ts
-var parseRawColumn = (col, tableName, ctes) => {
-  if (col.includes("(")) {
-    const [fn, rest] = col.split("(");
-    const colName = rest.replace(")", "");
-    const [table, name] = colName.includes(".") ? colName.split(".") : [tableName, colName];
-    return { type: "Column", table, name, alias: col };
-  }
-  if (col.includes(".")) {
-    const [potentialCteName, columnName] = col.split(".");
-    const hasCte = ctes?.some((cte) => cte.name === potentialCteName);
-    if (hasCte) {
-      return { type: "Column", table: tableName, name: col };
-    }
-    return { type: "Column", table: potentialCteName, name: columnName };
-  }
-  return { type: "Column", table: tableName, name: col };
-};
-
-// src/query-builder/query-ast-service.ts
-var QueryAstService = class {
-  /**
-   * Creates a new QueryAstService instance
-   * @param table - Table definition
-   * @param state - Current query state
-   */
-  constructor(table, state) {
-    this.table = table;
-    this.state = state;
-  }
-  /**
-   * Selects columns for the query
-   * @param columns - Columns to select (key: alias, value: column definition or expression)
-   * @returns Column selection result with updated state and added columns
-   */
-  select(columns) {
-    const existingAliases = new Set(
-      this.state.ast.columns.map((c) => c.alias || c.name)
-    );
-    const from = this.state.ast.from;
-    const rootTableName = from.type === "Table" && from.alias ? from.alias : this.table.name;
-    const newCols = Object.entries(columns).reduce((acc, [alias, val]) => {
-      if (existingAliases.has(alias)) return acc;
-      if (isExpressionSelectionNode(val)) {
-        acc.push({ ...val, alias });
-        return acc;
-      }
-      const colDef = val;
-      const resolvedTable = colDef.table && colDef.table === this.table.name && from.type === "Table" && from.alias ? from.alias : colDef.table || rootTableName;
-      acc.push({
-        type: "Column",
-        table: resolvedTable,
-        name: colDef.name,
-        alias
-      });
-      return acc;
-    }, []);
-    const nextState = this.state.withColumns(newCols);
-    return { state: nextState, addedColumns: newCols };
-  }
-  /**
-   * Selects raw column expressions (best-effort parser for simple references/functions)
-   * @param cols - Raw column expressions
-   * @returns Column selection result with updated state and added columns
-   */
-  selectRaw(cols) {
-    const from = this.state.ast.from;
-    const defaultTable = from.type === "Table" && from.alias ? from.alias : this.table.name;
-    const newCols = cols.map((col) => parseRawColumn(col, defaultTable, this.state.ast.ctes));
-    const nextState = this.state.withColumns(newCols);
-    return { state: nextState, addedColumns: newCols };
-  }
-  /**
-   * Adds a Common Table Expression (CTE) to the query
-   * @param name - Name of the CTE
-   * @param query - Query for the CTE
-   * @param columns - Optional column names for the CTE
-   * @param recursive - Whether the CTE is recursive
-   * @returns Updated query state with CTE
-   */
-  withCte(name, query, columns, recursive = false) {
-    const cte = {
-      type: "CommonTableExpression",
-      name,
-      query,
-      columns,
-      recursive
-    };
-    return this.state.withCte(cte);
-  }
-  /**
-   * Adds a set operation (UNION/UNION ALL/INTERSECT/EXCEPT) to the query
-   * @param operator - Set operator
-   * @param query - Right-hand side query
-   * @returns Updated query state with set operation
-   */
-  withSetOperation(operator, query) {
-    const op = {
-      type: "SetOperation",
-      operator,
-      query
-    };
-    return this.state.withSetOperation(op);
-  }
-  /**
-   * Replaces the FROM clause for the current query.
-   * @param from - Table source to use in the FROM clause
-   * @returns Updated query state with new FROM
-   */
-  withFrom(from) {
-    return this.state.withFrom(from);
-  }
-  /**
-   * Selects a subquery as a column
-   * @param alias - Alias for the subquery
-   * @param query - Subquery to select
-   * @returns Updated query state with subquery selection
-   */
-  selectSubquery(alias, query) {
-    const node = { type: "ScalarSubquery", query, alias };
-    return this.state.withColumns([node]);
-  }
-  /**
-   * Adds a JOIN clause to the query
-   * @param join - Join node to add
-   * @returns Updated query state with JOIN
-   */
-  withJoin(join) {
-    return this.state.withJoin(join);
-  }
-  /**
-   * Adds a WHERE clause to the query
-   * @param expr - Expression for the WHERE clause
-   * @returns Updated query state with WHERE clause
-   */
-  withWhere(expr) {
-    const combined = this.combineExpressions(this.state.ast.where, expr);
-    return this.state.withWhere(combined);
-  }
-  /**
-   * Adds a GROUP BY clause to the query
-   * @param col - Column to group by
-   * @returns Updated query state with GROUP BY clause
-   */
-  withGroupBy(col) {
-    const from = this.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const node = buildColumnNode(tableRef, col);
-    return this.state.withGroupBy([node]);
-  }
-  /**
-   * Adds a HAVING clause to the query
-   * @param expr - Expression for the HAVING clause
-   * @returns Updated query state with HAVING clause
-   */
-  withHaving(expr) {
-    const combined = this.combineExpressions(this.state.ast.having, expr);
-    return this.state.withHaving(combined);
-  }
-  /**
-   * Adds an ORDER BY clause to the query
-   * @param col - Column to order by
-   * @param direction - Order direction (ASC/DESC)
-   * @returns Updated query state with ORDER BY clause
-   */
-  withOrderBy(col, direction) {
-    const from = this.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const node = buildColumnNode(tableRef, col);
-    return this.state.withOrderBy([{ type: "OrderBy", column: node, direction }]);
-  }
-  /**
-   * Adds a DISTINCT clause to the query
-   * @param cols - Columns to make distinct
-   * @returns Updated query state with DISTINCT clause
-   */
-  withDistinct(cols) {
-    return this.state.withDistinct(cols);
-  }
-  /**
-   * Adds a LIMIT clause to the query
-   * @param limit - Maximum number of rows to return
-   * @returns Updated query state with LIMIT clause
-   */
-  withLimit(limit) {
-    return this.state.withLimit(limit);
-  }
-  /**
-   * Adds an OFFSET clause to the query
-   * @param offset - Number of rows to skip
-   * @returns Updated query state with OFFSET clause
-   */
-  withOffset(offset) {
-    return this.state.withOffset(offset);
-  }
-  /**
-   * Combines expressions with AND operator
-   * @param existing - Existing expression
-   * @param next - New expression to combine
-   * @returns Combined expression
-   */
-  combineExpressions(existing, next) {
-    return existing ? and(existing, next) : next;
-  }
-};
-
-// src/query-builder/relation-projection-helper.ts
-var RelationProjectionHelper = class {
-  /**
-   * Creates a new RelationProjectionHelper instance
-   * @param table - Table definition
-   * @param selectColumns - Callback for selecting columns
-   */
-  constructor(table, selectColumns) {
-    this.table = table;
-    this.selectColumns = selectColumns;
-  }
-  /**
-   * Ensures base projection is included in the query
-   * @param state - Current query state
-   * @param hydration - Hydration manager
-   * @returns Relation result with updated state and hydration
-   */
-  ensureBaseProjection(state, hydration) {
-    const primaryKey = findPrimaryKey(this.table);
-    if (!this.hasBaseProjection(state)) {
-      return this.selectColumns(state, hydration, this.getBaseColumns());
-    }
-    if (primaryKey && !this.hasPrimarySelected(state, primaryKey) && this.table.columns[primaryKey]) {
-      return this.selectColumns(state, hydration, {
-        [primaryKey]: this.table.columns[primaryKey]
-      });
-    }
-    return { state, hydration };
-  }
-  /**
-   * Checks if base projection exists in the query
-   * @param state - Current query state
-   * @returns True if base projection exists
-   */
-  hasBaseProjection(state) {
-    return state.ast.columns.some((col) => !isRelationAlias(col.alias));
-  }
-  /**
-   * Checks if primary key is selected in the query
-   * @param state - Current query state
-   * @param primaryKey - Primary key name
-   * @returns True if primary key is selected
-   */
-  hasPrimarySelected(state, primaryKey) {
-    return state.ast.columns.some((col) => {
-      const alias = col.alias;
-      const name = alias || col.name;
-      return !isRelationAlias(alias) && name === primaryKey;
-    });
-  }
-  /**
-   * Gets all base columns for the table
-   * @returns Record of all table columns
-   */
-  getBaseColumns() {
-    return Object.keys(this.table.columns).reduce((acc, key) => {
-      acc[key] = this.table.columns[key];
-      return acc;
-    }, {});
-  }
-};
-
-// src/query-builder/relation-conditions.ts
-var assertNever = (value) => {
-  throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
-};
-var baseRelationCondition = (root, relation, rootAlias) => {
-  const rootTable = rootAlias || root.name;
-  const defaultLocalKey = relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne ? findPrimaryKey(root) : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
-  switch (relation.type) {
-    case RelationKinds.HasMany:
-    case RelationKinds.HasOne:
-      return eq(
-        { type: "Column", table: relation.target.name, name: relation.foreignKey },
-        { type: "Column", table: rootTable, name: localKey }
-      );
-    case RelationKinds.BelongsTo:
-      return eq(
-        { type: "Column", table: relation.target.name, name: localKey },
-        { type: "Column", table: rootTable, name: relation.foreignKey }
-      );
-    case RelationKinds.BelongsToMany:
-      throw new Error("BelongsToMany relations do not support the standard join condition builder");
-    default:
-      return assertNever(relation);
-  }
-};
-var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra, rootAlias) => {
-  const rootKey = relation.localKey || findPrimaryKey(root);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-  const rootTable = rootAlias || root.name;
-  const pivotCondition = eq(
-    { type: "Column", table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: "Column", table: rootTable, name: rootKey }
-  );
-  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
-  let targetCondition = eq(
-    { type: "Column", table: relation.target.name, name: targetKey },
-    { type: "Column", table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
-  );
-  if (extra) {
-    targetCondition = and(targetCondition, extra);
-  }
-  const targetJoin = createJoinNode(
-    joinKind,
-    relation.target.name,
-    targetCondition,
-    relationName
-  );
-  return [pivotJoin, targetJoin];
-};
-var buildRelationJoinCondition = (root, relation, extra, rootAlias) => {
-  const base = baseRelationCondition(root, relation, rootAlias);
-  return extra ? and(base, extra) : base;
-};
-var buildRelationCorrelation = (root, relation, rootAlias) => {
-  return baseRelationCondition(root, relation, rootAlias);
-};
-
-// src/core/ast/join-metadata.ts
-var getJoinRelationName = (join) => join.meta?.relationName;
-
-// src/query-builder/relation-service.ts
-var RelationService = class {
-  /**
-   * Creates a new RelationService instance
-   * @param table - Table definition
-   * @param state - Current query state
-   * @param hydration - Hydration manager
-   */
-  constructor(table, state, hydration, createQueryAstService) {
-    this.table = table;
-    this.state = state;
-    this.hydration = hydration;
-    this.createQueryAstService = createQueryAstService;
-    this.projectionHelper = new RelationProjectionHelper(
-      table,
-      (state2, hydration2, columns) => this.selectColumns(state2, hydration2, columns)
-    );
-  }
-  /**
-   * Joins a relation to the query
-   * @param relationName - Name of the relation to join
-   * @param joinKind - Type of join to use
-   * @param extraCondition - Additional join condition
-   * @returns Relation result with updated state and hydration
-   */
-  joinRelation(relationName, joinKind, extraCondition) {
-    const nextState = this.withJoin(this.state, relationName, joinKind, extraCondition);
-    return { state: nextState, hydration: this.hydration };
-  }
-  /**
-   * Matches records based on a relation with an optional predicate
-   * @param relationName - Name of the relation to match
-   * @param predicate - Optional predicate expression
-   * @returns Relation result with updated state and hydration
-   */
-  match(relationName, predicate) {
-    const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
-    const pk = findPrimaryKey(this.table);
-    const distinctCols = [{ type: "Column", table: this.rootTableName(), name: pk }];
-    const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
-    const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
-    return { state: nextState, hydration: joined.hydration };
-  }
-  /**
-   * Includes a relation in the query result
-   * @param relationName - Name of the relation to include
-   * @param options - Options for relation inclusion
-   * @returns Relation result with updated state and hydration
-   */
-  include(relationName, options) {
-    let state = this.state;
-    let hydration = this.hydration;
-    const relation = this.getRelation(relationName);
-    const aliasPrefix = options?.aliasPrefix ?? relationName;
-    const alreadyJoined = state.ast.joins.some((j) => getJoinRelationName(j) === relationName);
-    if (!alreadyJoined) {
-      const joined = this.joinRelation(relationName, options?.joinKind ?? JOIN_KINDS.LEFT, options?.filter);
-      state = joined.state;
-    }
-    const projectionResult = this.projectionHelper.ensureBaseProjection(state, hydration);
-    state = projectionResult.state;
-    hydration = projectionResult.hydration;
-    const targetColumns = options?.columns?.length ? options.columns : Object.keys(relation.target.columns);
-    const buildTypedSelection = (columns, prefix, keys, missingMsg) => {
-      return keys.reduce((acc, key) => {
-        const def = columns[key];
-        if (!def) {
-          throw new Error(missingMsg(key));
-        }
-        acc[makeRelationAlias(prefix, key)] = def;
-        return acc;
-      }, {});
-    };
-    const targetSelection = buildTypedSelection(
-      relation.target.columns,
-      aliasPrefix,
-      targetColumns,
-      (key) => `Column '${key}' not found on relation '${relationName}'`
-    );
-    if (relation.type !== RelationKinds.BelongsToMany) {
-      const relationSelectionResult2 = this.selectColumns(state, hydration, targetSelection);
-      state = relationSelectionResult2.state;
-      hydration = relationSelectionResult2.hydration;
-      hydration = hydration.onRelationIncluded(
-        state,
-        relation,
-        relationName,
-        aliasPrefix,
-        targetColumns
-      );
-      return { state, hydration };
-    }
-    const many = relation;
-    const pivotAliasPrefix = options?.pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
-    const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
-    const pivotColumns = options?.pivot?.columns ?? many.defaultPivotColumns ?? buildDefaultPivotColumns(many, pivotPk);
-    const pivotSelection = buildTypedSelection(
-      many.pivotTable.columns,
-      pivotAliasPrefix,
-      pivotColumns,
-      (key) => `Column '${key}' not found on pivot table '${many.pivotTable.name}'`
-    );
-    const combinedSelection = {
-      ...targetSelection,
-      ...pivotSelection
-    };
-    const relationSelectionResult = this.selectColumns(state, hydration, combinedSelection);
-    state = relationSelectionResult.state;
-    hydration = relationSelectionResult.hydration;
-    hydration = hydration.onRelationIncluded(
-      state,
-      relation,
-      relationName,
-      aliasPrefix,
-      targetColumns,
-      { aliasPrefix: pivotAliasPrefix, columns: pivotColumns }
-    );
-    return { state, hydration };
-  }
-  /**
-   * Applies relation correlation to a query AST
-   * @param relationName - Name of the relation
-   * @param ast - Query AST to modify
-   * @returns Modified query AST with relation correlation
-   */
-  applyRelationCorrelation(relationName, ast, additionalCorrelation) {
-    const relation = this.getRelation(relationName);
-    const rootAlias = this.state.ast.from.type === "Table" ? this.state.ast.from.alias : void 0;
-    let correlation = buildRelationCorrelation(this.table, relation, rootAlias);
-    if (additionalCorrelation) {
-      correlation = and(correlation, additionalCorrelation);
-    }
-    const whereInSubquery = ast.where ? and(correlation, ast.where) : correlation;
-    return {
-      ...ast,
-      where: whereInSubquery
-    };
-  }
-  /**
-   * Creates a join node for a relation
-   * @param state - Current query state
-   * @param relationName - Name of the relation
-   * @param joinKind - Type of join to use
-   * @param extraCondition - Additional join condition
-   * @returns Updated query state with join
-   */
-  withJoin(state, relationName, joinKind, extraCondition) {
-    const relation = this.getRelation(relationName);
-    const rootAlias = state.ast.from.type === "Table" ? state.ast.from.alias : void 0;
-    if (relation.type === RelationKinds.BelongsToMany) {
-      const joins = buildBelongsToManyJoins(
-        this.table,
-        relationName,
-        relation,
-        joinKind,
-        extraCondition,
-        rootAlias
-      );
-      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
-    }
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition, rootAlias);
-    const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
-    return this.astService(state).withJoin(joinNode);
-  }
-  /**
-   * Selects columns for a relation
-   * @param state - Current query state
-   * @param hydration - Hydration manager
-   * @param columns - Columns to select
-   * @returns Relation result with updated state and hydration
-   */
-  selectColumns(state, hydration, columns) {
-    const { state: nextState, addedColumns } = this.astService(state).select(columns);
-    return {
-      state: nextState,
-      hydration: hydration.onColumnsSelected(nextState, addedColumns)
-    };
-  }
-  /**
-   * Gets a relation definition by name
-   * @param relationName - Name of the relation
-   * @returns Relation definition
-   * @throws Error if relation is not found
-   */
-  getRelation(relationName) {
-    const relation = this.table.relations[relationName];
-    if (!relation) {
-      throw new Error(`Relation '${relationName}' not found on table '${this.table.name}'`);
-    }
-    return relation;
-  }
-  /**
-   * Creates a QueryAstService instance
-   * @param state - Current query state
-   * @returns QueryAstService instance
-   */
-  astService(state = this.state) {
-    return this.createQueryAstService(this.table, state);
-  }
-  rootTableName() {
-    const from = this.state.ast.from;
-    if (from.type === "Table" && from.alias) return from.alias;
-    return this.table.name;
-  }
-};
-
-// src/query-builder/select-query-builder-deps.ts
-var defaultCreateQueryAstService = (table, state) => new QueryAstService(table, state);
-var defaultCreateHydrationPlanner = (table) => new HydrationPlanner(table);
-var defaultCreateHydration = (table, plannerFactory) => new HydrationManager(table, plannerFactory(table));
-var resolveSelectQueryBuilderDependencies = (overrides = {}) => {
-  const createQueryAstService = overrides.createQueryAstService ?? defaultCreateQueryAstService;
-  const createHydrationPlanner = overrides.createHydrationPlanner ?? defaultCreateHydrationPlanner;
-  const createHydration = overrides.createHydration ?? ((table) => defaultCreateHydration(table, createHydrationPlanner));
-  const createRelationService = overrides.createRelationService ?? ((table, state, hydration) => new RelationService(table, state, hydration, createQueryAstService));
-  return {
-    createState: overrides.createState ?? ((table) => new SelectQueryState(table)),
-    createHydration,
-    createHydrationPlanner,
-    createQueryAstService,
-    createRelationService
-  };
-};
-var defaultSelectQueryBuilderDependencies = resolveSelectQueryBuilderDependencies();
-
-// src/query-builder/column-selector.ts
-var ColumnSelector = class {
-  /**
-   * Creates a new ColumnSelector instance
-   * @param env - Query builder environment
-   */
-  constructor(env) {
-    this.env = env;
-  }
-  /**
-   * Selects columns for the query
-   * @param context - Current query context
-   * @param columns - Columns to select
-   * @returns Updated query context with selected columns
-   */
-  select(context, columns) {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const { state: nextState, addedColumns } = astService.select(columns);
-    return {
-      state: nextState,
-      hydration: context.hydration.onColumnsSelected(nextState, addedColumns)
-    };
-  }
-  /**
-   * Selects raw column expressions
-   * @param context - Current query context
-   * @param columns - Raw column expressions
-   * @returns Updated query context with raw column selections
-   */
-  selectRaw(context, columns) {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.selectRaw(columns).state;
-    return { state: nextState, hydration: context.hydration };
-  }
-  /**
-   * Selects a subquery as a column
-   * @param context - Current query context
-   * @param alias - Alias for the subquery
-   * @param query - Subquery to select
-   * @returns Updated query context with subquery selection
-   */
-  selectSubquery(context, alias, query) {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.selectSubquery(alias, query);
-    return { state: nextState, hydration: context.hydration };
-  }
-  /**
-   * Adds DISTINCT clause to the query
-   * @param context - Current query context
-   * @param columns - Columns to make distinct
-   * @returns Updated query context with DISTINCT clause
-   */
-  distinct(context, columns) {
-    const from = context.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
-    const nodes = columns.map((col) => buildColumnNode(tableRef, col));
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withDistinct(nodes);
-    return { state: nextState, hydration: context.hydration };
-  }
-};
-
-// src/query-builder/relation-manager.ts
-var RelationManager = class {
-  /**
-   * Creates a new RelationManager instance
-   * @param env - Query builder environment
-   */
-  constructor(env) {
-    this.env = env;
-  }
-  /**
-   * Matches records based on a relation with an optional predicate
-   * @param context - Current query context
-   * @param relationName - Name of the relation to match
-   * @param predicate - Optional predicate expression
-   * @returns Updated query context with relation match
-   */
-  match(context, relationName, predicate) {
-    const result = this.createService(context).match(relationName, predicate);
-    return { state: result.state, hydration: result.hydration };
-  }
-  /**
-   * Joins a relation to the query
-   * @param context - Current query context
-   * @param relationName - Name of the relation to join
-   * @param joinKind - Type of join to use
-   * @param extraCondition - Additional join condition
-   * @returns Updated query context with relation join
-   */
-  joinRelation(context, relationName, joinKind, extraCondition) {
-    const result = this.createService(context).joinRelation(relationName, joinKind, extraCondition);
-    return { state: result.state, hydration: result.hydration };
-  }
-  /**
-   * Includes a relation in the query result
-   * @param context - Current query context
-   * @param relationName - Name of the relation to include
-   * @param options - Options for relation inclusion
-   * @returns Updated query context with included relation
-   */
-  include(context, relationName, options) {
-    const result = this.createService(context).include(relationName, options);
-    return { state: result.state, hydration: result.hydration };
-  }
-  /**
-   * Applies relation correlation to a query AST
-   * @param context - Current query context
-   * @param relationName - Name of the relation
-   * @param ast - Query AST to modify
-   * @returns Modified query AST with relation correlation
-   */
-  applyRelationCorrelation(context, relationName, ast, additionalCorrelation) {
-    return this.createService(context).applyRelationCorrelation(relationName, ast, additionalCorrelation);
-  }
-  /**
-   * Creates a relation service instance
-   * @param context - Current query context
-   * @returns Relation service instance
-   */
-  createService(context) {
-    return this.env.deps.createRelationService(this.env.table, context.state, context.hydration);
-  }
-};
-
-// src/orm/hydration.ts
-var hydrateRows = (rows, plan) => {
-  if (!plan || !rows.length) return rows;
-  const rootMap = /* @__PURE__ */ new Map();
-  const relationIndex = /* @__PURE__ */ new Map();
-  const getOrCreateParent = (row) => {
-    const rootId = row[plan.rootPrimaryKey];
-    if (rootId === void 0) return void 0;
-    if (!rootMap.has(rootId)) {
-      rootMap.set(rootId, createBaseRow(row, plan));
-    }
-    return rootMap.get(rootId);
-  };
-  const getRelationSeenSet = (rootId, relationName) => {
-    let byRelation = relationIndex.get(rootId);
-    if (!byRelation) {
-      byRelation = {};
-      relationIndex.set(rootId, byRelation);
-    }
-    let seen = byRelation[relationName];
-    if (!seen) {
-      seen = /* @__PURE__ */ new Set();
-      byRelation[relationName] = seen;
-    }
-    return seen;
-  };
-  for (const row of rows) {
-    const rootId = row[plan.rootPrimaryKey];
-    if (rootId === void 0) continue;
-    const parent = getOrCreateParent(row);
-    if (!parent) continue;
-    for (const rel of plan.relations) {
-      const childPkKey = makeRelationAlias(rel.aliasPrefix, rel.targetPrimaryKey);
-      const childPk = row[childPkKey];
-      if (childPk === null || childPk === void 0) continue;
-      const seen = getRelationSeenSet(rootId, rel.name);
-      if (seen.has(childPk)) continue;
-      seen.add(childPk);
-      if (rel.type === RelationKinds.HasOne) {
-        if (!parent[rel.name]) {
-          parent[rel.name] = buildChild(row, rel);
-        }
-        continue;
-      }
-      const bucket = parent[rel.name];
-      bucket.push(buildChild(row, rel));
-    }
-  }
-  return Array.from(rootMap.values());
-};
-var createBaseRow = (row, plan) => {
-  const base = {};
-  const baseKeys = plan.rootColumns.length ? plan.rootColumns : Object.keys(row).filter((k) => !isRelationAlias(k));
-  for (const key of baseKeys) {
-    base[key] = row[key];
-  }
-  for (const rel of plan.relations) {
-    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
-  }
-  return base;
-};
-var buildChild = (row, rel) => {
-  const child = {};
-  for (const col of rel.columns) {
-    const key = makeRelationAlias(rel.aliasPrefix, col);
-    child[col] = row[key];
-  }
-  const pivot = buildPivot(row, rel);
-  if (pivot) {
-    child._pivot = pivot;
-  }
-  return child;
-};
-var buildPivot = (row, rel) => {
-  if (!rel.pivot) return void 0;
-  const pivot = {};
-  for (const col of rel.pivot.columns) {
-    const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
-    pivot[col] = row[key];
-  }
-  const hasValue = Object.values(pivot).some((v) => v !== null && v !== void 0);
-  return hasValue ? pivot : void 0;
-};
-
-// src/orm/entity-meta.ts
-var ENTITY_META = Symbol("EntityMeta");
-var toKey = (value) => value === null || value === void 0 ? "" : String(value);
-var getHydrationRows = (meta, relationName, key) => {
-  const map = meta.relationHydration.get(relationName);
-  if (!map) return void 0;
-  const rows = map.get(toKey(key));
-  if (!rows) return void 0;
-  return Array.isArray(rows) ? rows : void 0;
-};
-var getHydrationRecord = (meta, relationName, key) => {
-  const map = meta.relationHydration.get(relationName);
-  if (!map) return void 0;
-  const value = map.get(toKey(key));
-  if (!value) return void 0;
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-  return value;
-};
-var getEntityMeta = (entity) => {
-  if (!entity || typeof entity !== "object") return void 0;
-  return entity[ENTITY_META];
-};
-var hasEntityMeta = (entity) => {
-  return Boolean(getEntityMeta(entity));
-};
-
-// src/orm/relations/has-many.ts
-var toKey2 = (value) => value === null || value === void 0 ? "" : String(value);
-var hideInternal = (obj, keys) => {
-  for (const key of keys) {
-    Object.defineProperty(obj, key, {
-      value: obj[key],
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
-  }
-};
-var DefaultHasManyCollection = class {
-  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
-    this.ctx = ctx;
-    this.meta = meta;
-    this.root = root;
-    this.relationName = relationName;
-    this.relation = relation;
-    this.rootTable = rootTable;
-    this.loader = loader;
-    this.createEntity = createEntity;
-    this.localKey = localKey;
-    this.loaded = false;
-    this.items = [];
-    this.added = /* @__PURE__ */ new Set();
-    this.removed = /* @__PURE__ */ new Set();
-    hideInternal(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "localKey"]);
-    this.hydrateFromCache();
-  }
-  async load() {
-    if (this.loaded) return this.items;
-    const map = await this.loader();
-    const key = toKey2(this.root[this.localKey]);
-    const rows = map.get(key) ?? [];
-    this.items = rows.map((row) => this.createEntity(row));
-    this.loaded = true;
-    return this.items;
-  }
-  getItems() {
-    return this.items;
-  }
-  add(data) {
-    const keyValue = this.root[this.localKey];
-    const childRow = {
-      ...data,
-      [this.relation.foreignKey]: keyValue
-    };
-    const entity = this.createEntity(childRow);
-    this.added.add(entity);
-    this.items.push(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "add", entity }
-    );
-    return entity;
-  }
-  attach(entity) {
-    const keyValue = this.root[this.localKey];
-    entity[this.relation.foreignKey] = keyValue;
-    this.ctx.markDirty(entity);
-    this.items.push(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "attach", entity }
-    );
-  }
-  remove(entity) {
-    this.items = this.items.filter((item) => item !== entity);
-    this.removed.add(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "remove", entity }
-    );
-  }
-  clear() {
-    for (const entity of [...this.items]) {
-      this.remove(entity);
-    }
-  }
-  get relationKey() {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-  hydrateFromCache() {
-    const keyValue = this.root[this.localKey];
-    if (keyValue === void 0 || keyValue === null) return;
-    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
-    if (!rows?.length) return;
-    this.items = rows.map((row) => this.createEntity(row));
-    this.loaded = true;
-  }
-  toJSON() {
-    return this.items;
-  }
-};
-
-// src/orm/relations/has-one.ts
-var toKey3 = (value) => value === null || value === void 0 ? "" : String(value);
-var hideInternal2 = (obj, keys) => {
-  for (const key of keys) {
-    Object.defineProperty(obj, key, {
-      value: obj[key],
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
-  }
-};
-var DefaultHasOneReference = class {
-  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
-    this.ctx = ctx;
-    this.meta = meta;
-    this.root = root;
-    this.relationName = relationName;
-    this.relation = relation;
-    this.rootTable = rootTable;
-    this.loader = loader;
-    this.createEntity = createEntity;
-    this.localKey = localKey;
-    this.loaded = false;
-    this.current = null;
-    hideInternal2(this, [
-      "ctx",
-      "meta",
-      "root",
-      "relationName",
-      "relation",
-      "rootTable",
-      "loader",
-      "createEntity",
-      "localKey"
-    ]);
-    this.populateFromHydrationCache();
-  }
-  async load() {
-    if (this.loaded) return this.current;
-    const map = await this.loader();
-    const keyValue = this.root[this.localKey];
-    if (keyValue === void 0 || keyValue === null) {
-      this.loaded = true;
-      return this.current;
-    }
-    const row = map.get(toKey3(keyValue));
-    this.current = row ? this.createEntity(row) : null;
-    this.loaded = true;
-    return this.current;
-  }
-  get() {
-    return this.current;
-  }
-  set(data) {
-    if (data === null) {
-      return this.detachCurrent();
-    }
-    const entity = hasEntityMeta(data) ? data : this.createEntity(data);
-    if (this.current && this.current !== entity) {
-      this.ctx.registerRelationChange(
-        this.root,
-        this.relationKey,
-        this.rootTable,
-        this.relationName,
-        this.relation,
-        { kind: "remove", entity: this.current }
-      );
-    }
-    this.assignForeignKey(entity);
-    this.current = entity;
-    this.loaded = true;
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "attach", entity }
-    );
-    return entity;
-  }
-  toJSON() {
-    return this.current;
-  }
-  detachCurrent() {
-    const previous = this.current;
-    if (!previous) return null;
-    this.current = null;
-    this.loaded = true;
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "remove", entity: previous }
-    );
-    return null;
-  }
-  assignForeignKey(entity) {
-    const keyValue = this.root[this.localKey];
-    entity[this.relation.foreignKey] = keyValue;
-  }
-  get relationKey() {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-  populateFromHydrationCache() {
-    const keyValue = this.root[this.localKey];
-    if (keyValue === void 0 || keyValue === null) return;
-    const row = getHydrationRecord(this.meta, this.relationName, keyValue);
-    if (!row) return;
-    this.current = this.createEntity(row);
-    this.loaded = true;
-  }
-};
-
-// src/orm/relations/belongs-to.ts
-var toKey4 = (value) => value === null || value === void 0 ? "" : String(value);
-var hideInternal3 = (obj, keys) => {
-  for (const key of keys) {
-    Object.defineProperty(obj, key, {
-      value: obj[key],
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
-  }
-};
-var DefaultBelongsToReference = class {
-  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, targetKey) {
-    this.ctx = ctx;
-    this.meta = meta;
-    this.root = root;
-    this.relationName = relationName;
-    this.relation = relation;
-    this.rootTable = rootTable;
-    this.loader = loader;
-    this.createEntity = createEntity;
-    this.targetKey = targetKey;
-    this.loaded = false;
-    this.current = null;
-    hideInternal3(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "targetKey"]);
-    this.populateFromHydrationCache();
-  }
-  async load() {
-    if (this.loaded) return this.current;
-    const map = await this.loader();
-    const fkValue = this.root[this.relation.foreignKey];
-    if (fkValue === null || fkValue === void 0) {
-      this.current = null;
-    } else {
-      const row = map.get(toKey4(fkValue));
-      this.current = row ? this.createEntity(row) : null;
-    }
-    this.loaded = true;
-    return this.current;
-  }
-  get() {
-    return this.current;
-  }
-  set(data) {
-    if (data === null) {
-      const previous = this.current;
-      this.root[this.relation.foreignKey] = null;
-      this.current = null;
-      this.ctx.registerRelationChange(
-        this.root,
-        this.relationKey,
-        this.rootTable,
-        this.relationName,
-        this.relation,
-        { kind: "remove", entity: previous }
-      );
-      return null;
-    }
-    const entity = hasEntityMeta(data) ? data : this.createEntity(data);
-    const pkValue = entity[this.targetKey];
-    if (pkValue !== void 0) {
-      this.root[this.relation.foreignKey] = pkValue;
-    }
-    this.current = entity;
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "attach", entity }
-    );
-    return entity;
-  }
-  get relationKey() {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-  populateFromHydrationCache() {
-    const fkValue = this.root[this.relation.foreignKey];
-    if (fkValue === void 0 || fkValue === null) return;
-    const row = getHydrationRecord(this.meta, this.relationName, fkValue);
-    if (!row) return;
-    this.current = this.createEntity(row);
-    this.loaded = true;
-  }
-  toJSON() {
-    return this.current;
-  }
-};
-
-// src/orm/relations/many-to-many.ts
-var toKey5 = (value) => value === null || value === void 0 ? "" : String(value);
-var hideInternal4 = (obj, keys) => {
-  for (const key of keys) {
-    Object.defineProperty(obj, key, {
-      value: obj[key],
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
-  }
-};
-var DefaultManyToManyCollection = class {
-  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
-    this.ctx = ctx;
-    this.meta = meta;
-    this.root = root;
-    this.relationName = relationName;
-    this.relation = relation;
-    this.rootTable = rootTable;
-    this.loader = loader;
-    this.createEntity = createEntity;
-    this.localKey = localKey;
-    this.loaded = false;
-    this.items = [];
-    hideInternal4(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "localKey"]);
-    this.hydrateFromCache();
-  }
-  async load() {
-    if (this.loaded) return this.items;
-    const map = await this.loader();
-    const key = toKey5(this.root[this.localKey]);
-    const rows = map.get(key) ?? [];
-    this.items = rows.map((row) => {
-      const entity = this.createEntity(row);
-      if (row._pivot) {
-        entity._pivot = row._pivot;
-      }
-      return entity;
-    });
-    this.loaded = true;
-    return this.items;
-  }
-  getItems() {
-    return this.items;
-  }
-  attach(target) {
-    const entity = this.ensureEntity(target);
-    const id = this.extractId(entity);
-    if (id == null) return;
-    if (this.items.some((item) => this.extractId(item) === id)) {
-      return;
-    }
-    this.items.push(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "attach", entity }
-    );
-  }
-  detach(target) {
-    const id = typeof target === "number" || typeof target === "string" ? target : this.extractId(target);
-    if (id == null) return;
-    const existing = this.items.find((item) => this.extractId(item) === id);
-    if (!existing) return;
-    this.items = this.items.filter((item) => this.extractId(item) !== id);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: "detach", entity: existing }
-    );
-  }
-  async syncByIds(ids) {
-    await this.load();
-    const targetKey = this.relation.targetKey || findPrimaryKey(this.relation.target);
-    const normalized = new Set(ids.map((id) => toKey5(id)));
-    const currentIds = new Set(this.items.map((item) => toKey5(this.extractId(item))));
-    for (const id of normalized) {
-      if (!currentIds.has(id)) {
-        this.attach(id);
-      }
-    }
-    for (const item of [...this.items]) {
-      const itemId = toKey5(this.extractId(item));
-      if (!normalized.has(itemId)) {
-        this.detach(item);
-      }
-    }
-  }
-  ensureEntity(target) {
-    if (typeof target === "number" || typeof target === "string") {
-      const stub = {
-        [this.targetKey]: target
-      };
-      return this.createEntity(stub);
-    }
-    return target;
-  }
-  extractId(entity) {
-    if (entity === null || entity === void 0) return null;
-    if (typeof entity === "number" || typeof entity === "string") {
-      return entity;
-    }
-    return entity[this.targetKey] ?? null;
-  }
-  get relationKey() {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-  get targetKey() {
-    return this.relation.targetKey || findPrimaryKey(this.relation.target);
-  }
-  hydrateFromCache() {
-    const keyValue = this.root[this.localKey];
-    if (keyValue === void 0 || keyValue === null) return;
-    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
-    if (!rows?.length) return;
-    this.items = rows.map((row) => {
-      const entity = this.createEntity(row);
-      if (row._pivot) {
-        entity._pivot = row._pivot;
-      }
-      return entity;
-    });
-    this.loaded = true;
-  }
-  toJSON() {
-    return this.items;
-  }
-};
-
-// src/orm/lazy-batch.ts
-var selectAllColumns = (table) => Object.entries(table.columns).reduce((acc, [name, def]) => {
-  acc[name] = def;
-  return acc;
-}, {});
-var rowsFromResults = (results) => {
-  const rows = [];
-  for (const result of results) {
-    const { columns, values } = result;
-    for (const valueRow of values) {
-      const row = {};
-      columns.forEach((column, idx) => {
-        row[column] = valueRow[idx];
-      });
-      rows.push(row);
-    }
-  }
-  return rows;
-};
-var executeQuery = async (ctx, qb) => {
-  const compiled = ctx.dialect.compileSelect(qb.getAST());
-  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
-  return rowsFromResults(results);
-};
-var toKey6 = (value) => value === null || value === void 0 ? "" : String(value);
-var loadHasManyRelation = async (ctx, rootTable, _relationName, relation) => {
-  const localKey = relation.localKey || findPrimaryKey(rootTable);
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const keys = /* @__PURE__ */ new Set();
-  for (const tracked of roots) {
-    const value = tracked.entity[localKey];
-    if (value !== null && value !== void 0) {
-      keys.add(value);
-    }
-  }
-  if (!keys.size) {
-    return /* @__PURE__ */ new Map();
-  }
-  const selectMap = selectAllColumns(relation.target);
-  const fb = new SelectQueryBuilder(relation.target).select(selectMap);
-  const fkColumn = relation.target.columns[relation.foreignKey];
-  if (!fkColumn) return /* @__PURE__ */ new Map();
-  fb.where(inList(fkColumn, Array.from(keys)));
-  const rows = await executeQuery(ctx, fb);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const fkValue = row[relation.foreignKey];
-    if (fkValue === null || fkValue === void 0) continue;
-    const key = toKey6(fkValue);
-    const bucket = grouped.get(key) ?? [];
-    bucket.push(row);
-    grouped.set(key, bucket);
-  }
-  return grouped;
-};
-var loadHasOneRelation = async (ctx, rootTable, _relationName, relation) => {
-  const localKey = relation.localKey || findPrimaryKey(rootTable);
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const keys = /* @__PURE__ */ new Set();
-  for (const tracked of roots) {
-    const value = tracked.entity[localKey];
-    if (value !== null && value !== void 0) {
-      keys.add(value);
-    }
-  }
-  if (!keys.size) {
-    return /* @__PURE__ */ new Map();
-  }
-  const selectMap = selectAllColumns(relation.target);
-  const qb = new SelectQueryBuilder(relation.target).select(selectMap);
-  const fkColumn = relation.target.columns[relation.foreignKey];
-  if (!fkColumn) return /* @__PURE__ */ new Map();
-  qb.where(inList(fkColumn, Array.from(keys)));
-  const rows = await executeQuery(ctx, qb);
-  const lookup = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const fkValue = row[relation.foreignKey];
-    if (fkValue === null || fkValue === void 0) continue;
-    const key = toKey6(fkValue);
-    if (!lookup.has(key)) {
-      lookup.set(key, row);
-    }
-  }
-  return lookup;
-};
-var loadBelongsToRelation = async (ctx, rootTable, _relationName, relation) => {
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const foreignKeys = /* @__PURE__ */ new Set();
-  for (const tracked of roots) {
-    const value = tracked.entity[relation.foreignKey];
-    if (value !== null && value !== void 0) {
-      foreignKeys.add(value);
-    }
-  }
-  if (!foreignKeys.size) {
-    return /* @__PURE__ */ new Map();
-  }
-  const selectMap = selectAllColumns(relation.target);
-  const qb = new SelectQueryBuilder(relation.target).select(selectMap);
-  const targetKey = relation.localKey || findPrimaryKey(relation.target);
-  const pkColumn = relation.target.columns[targetKey];
-  if (!pkColumn) return /* @__PURE__ */ new Map();
-  qb.where(inList(pkColumn, Array.from(foreignKeys)));
-  const rows = await executeQuery(ctx, qb);
-  const map = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const keyValue = row[targetKey];
-    if (keyValue === null || keyValue === void 0) continue;
-    map.set(toKey6(keyValue), row);
-  }
-  return map;
-};
-var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation) => {
-  const rootKey = relation.localKey || findPrimaryKey(rootTable);
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const rootIds = /* @__PURE__ */ new Set();
-  for (const tracked of roots) {
-    const value = tracked.entity[rootKey];
-    if (value !== null && value !== void 0) {
-      rootIds.add(value);
-    }
-  }
-  if (!rootIds.size) {
-    return /* @__PURE__ */ new Map();
-  }
-  const pivotSelect = selectAllColumns(relation.pivotTable);
-  const pivotQb = new SelectQueryBuilder(relation.pivotTable).select(pivotSelect);
-  const pivotFkCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
-  if (!pivotFkCol) return /* @__PURE__ */ new Map();
-  pivotQb.where(inList(pivotFkCol, Array.from(rootIds)));
-  const pivotRows = await executeQuery(ctx, pivotQb);
-  const rootLookup = /* @__PURE__ */ new Map();
-  const targetIds = /* @__PURE__ */ new Set();
-  for (const pivot of pivotRows) {
-    const rootValue = pivot[relation.pivotForeignKeyToRoot];
-    const targetValue = pivot[relation.pivotForeignKeyToTarget];
-    if (rootValue === null || rootValue === void 0 || targetValue === null || targetValue === void 0) {
-      continue;
-    }
-    const bucket = rootLookup.get(toKey6(rootValue)) ?? [];
-    bucket.push({
-      targetId: targetValue,
-      pivot: { ...pivot }
-    });
-    rootLookup.set(toKey6(rootValue), bucket);
-    targetIds.add(targetValue);
-  }
-  if (!targetIds.size) {
-    return /* @__PURE__ */ new Map();
-  }
-  const targetSelect = selectAllColumns(relation.target);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-  const targetPkColumn = relation.target.columns[targetKey];
-  if (!targetPkColumn) return /* @__PURE__ */ new Map();
-  const targetQb = new SelectQueryBuilder(relation.target).select(targetSelect);
-  targetQb.where(inList(targetPkColumn, Array.from(targetIds)));
-  const targetRows = await executeQuery(ctx, targetQb);
-  const targetMap = /* @__PURE__ */ new Map();
-  for (const row of targetRows) {
-    const pkValue = row[targetKey];
-    if (pkValue === null || pkValue === void 0) continue;
-    targetMap.set(toKey6(pkValue), row);
-  }
-  const result = /* @__PURE__ */ new Map();
-  for (const [rootId, entries] of rootLookup.entries()) {
-    const bucket = [];
-    for (const entry of entries) {
-      const targetRow = targetMap.get(toKey6(entry.targetId));
-      if (!targetRow) continue;
-      bucket.push({
-        ...targetRow,
-        _pivot: entry.pivot
-      });
-    }
-    result.set(rootId, bucket);
-  }
-  return result;
-};
-
-// src/orm/entity.ts
-var relationLoaderCache = (meta, relationName, factory) => {
-  if (meta.relationCache.has(relationName)) {
-    return meta.relationCache.get(relationName);
-  }
-  const promise = factory().then((value) => {
-    for (const tracked of meta.ctx.getEntitiesForTable(meta.table)) {
-      const otherMeta = getEntityMeta(tracked.entity);
-      if (!otherMeta) continue;
-      otherMeta.relationHydration.set(relationName, value);
-    }
-    return value;
-  });
-  meta.relationCache.set(relationName, promise);
-  for (const tracked of meta.ctx.getEntitiesForTable(meta.table)) {
-    const otherMeta = getEntityMeta(tracked.entity);
-    if (!otherMeta) continue;
-    otherMeta.relationCache.set(relationName, promise);
-  }
-  return promise;
-};
-var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
-  const target = { ...row };
-  const meta = {
-    ctx,
-    table,
-    lazyRelations: [...lazyRelations],
-    relationCache: /* @__PURE__ */ new Map(),
-    relationHydration: /* @__PURE__ */ new Map(),
-    relationWrappers: /* @__PURE__ */ new Map()
-  };
-  Object.defineProperty(target, ENTITY_META, {
-    value: meta,
-    enumerable: false,
-    writable: false
-  });
-  let proxy;
-  const handler = {
-    get(targetObj, prop, receiver) {
-      if (prop === ENTITY_META) {
-        return meta;
-      }
-      if (prop === "$load") {
-        return async (relationName) => {
-          const wrapper = getRelationWrapper(meta, relationName, proxy);
-          if (wrapper && typeof wrapper.load === "function") {
-            return wrapper.load();
-          }
-          return void 0;
-        };
-      }
-      if (typeof prop === "string" && table.relations[prop]) {
-        return getRelationWrapper(meta, prop, proxy);
-      }
-      return Reflect.get(targetObj, prop, receiver);
-    },
-    set(targetObj, prop, value, receiver) {
-      const result = Reflect.set(targetObj, prop, value, receiver);
-      if (typeof prop === "string" && table.columns[prop]) {
-        ctx.markDirty(proxy);
-      }
-      return result;
-    }
-  };
-  proxy = new Proxy(target, handler);
-  populateHydrationCache(proxy, row, meta);
-  return proxy;
-};
-var createEntityFromRow = (ctx, table, row, lazyRelations = []) => {
-  const pkName = findPrimaryKey(table);
-  const pkValue = row[pkName];
-  if (pkValue !== void 0 && pkValue !== null) {
-    const tracked = ctx.getEntity(table, pkValue);
-    if (tracked) return tracked;
-  }
-  const entity = createEntityProxy(ctx, table, row, lazyRelations);
-  if (pkValue !== void 0 && pkValue !== null) {
-    ctx.trackManaged(table, pkValue, entity);
-  } else {
-    ctx.trackNew(table, entity);
-  }
-  return entity;
-};
-var toKey7 = (value) => value === null || value === void 0 ? "" : String(value);
-var populateHydrationCache = (entity, row, meta) => {
-  for (const relationName of Object.keys(meta.table.relations)) {
-    const relation = meta.table.relations[relationName];
-    const data = row[relationName];
-    if (relation.type === RelationKinds.HasOne) {
-      const localKey = relation.localKey || findPrimaryKey(meta.table);
-      const rootValue = entity[localKey];
-      if (rootValue === void 0 || rootValue === null) continue;
-      if (!data || typeof data !== "object") continue;
-      const cache = /* @__PURE__ */ new Map();
-      cache.set(toKey7(rootValue), data);
-      meta.relationHydration.set(relationName, cache);
-      meta.relationCache.set(relationName, Promise.resolve(cache));
-      continue;
-    }
-    if (!Array.isArray(data)) continue;
-    if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-      const localKey = relation.localKey || findPrimaryKey(meta.table);
-      const rootValue = entity[localKey];
-      if (rootValue === void 0 || rootValue === null) continue;
-      const cache = /* @__PURE__ */ new Map();
-      cache.set(toKey7(rootValue), data);
-      meta.relationHydration.set(relationName, cache);
-      meta.relationCache.set(relationName, Promise.resolve(cache));
-      continue;
-    }
-    if (relation.type === RelationKinds.BelongsTo) {
-      const targetKey = relation.localKey || findPrimaryKey(relation.target);
-      const cache = /* @__PURE__ */ new Map();
-      for (const item of data) {
-        const pkValue = item[targetKey];
-        if (pkValue === void 0 || pkValue === null) continue;
-        cache.set(toKey7(pkValue), item);
-      }
-      if (cache.size) {
-        meta.relationHydration.set(relationName, cache);
-        meta.relationCache.set(relationName, Promise.resolve(cache));
-      }
-    }
-  }
-};
-var getRelationWrapper = (meta, relationName, owner) => {
-  if (meta.relationWrappers.has(relationName)) {
-    return meta.relationWrappers.get(relationName);
-  }
-  const relation = meta.table.relations[relationName];
-  if (!relation) return void 0;
-  const wrapper = instantiateWrapper(meta, relationName, relation, owner);
-  if (wrapper) {
-    meta.relationWrappers.set(relationName, wrapper);
-  }
-  return wrapper;
-};
-var instantiateWrapper = (meta, relationName, relation, owner) => {
-  switch (relation.type) {
-    case RelationKinds.HasOne: {
-      const hasOne2 = relation;
-      const localKey = hasOne2.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(
-        meta,
-        relationName,
-        () => loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne2)
-      );
-      return new DefaultHasOneReference(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        hasOne2,
-        meta.table,
-        loader,
-        (row) => createEntityFromRow(meta.ctx, hasOne2.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.HasMany: {
-      const hasMany2 = relation;
-      const localKey = hasMany2.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(
-        meta,
-        relationName,
-        () => loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany2)
-      );
-      return new DefaultHasManyCollection(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        hasMany2,
-        meta.table,
-        loader,
-        (row) => createEntityFromRow(meta.ctx, relation.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.BelongsTo: {
-      const belongsTo2 = relation;
-      const targetKey = belongsTo2.localKey || findPrimaryKey(belongsTo2.target);
-      const loader = () => relationLoaderCache(
-        meta,
-        relationName,
-        () => loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo2)
-      );
-      return new DefaultBelongsToReference(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        belongsTo2,
-        meta.table,
-        loader,
-        (row) => createEntityFromRow(meta.ctx, relation.target, row),
-        targetKey
-      );
-    }
-    case RelationKinds.BelongsToMany: {
-      const many = relation;
-      const localKey = many.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(
-        meta,
-        relationName,
-        () => loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many)
-      );
-      return new DefaultManyToManyCollection(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        many,
-        meta.table,
-        loader,
-        (row) => createEntityFromRow(meta.ctx, relation.target, row),
-        localKey
-      );
-    }
-    default:
-      return void 0;
-  }
-};
-
-// src/orm/execute.ts
-var flattenResults = (results) => {
-  const rows = [];
-  for (const result of results) {
-    const { columns, values } = result;
-    for (const valueRow of values) {
-      const row = {};
-      columns.forEach((column, idx) => {
-        row[column] = valueRow[idx];
-      });
-      rows.push(row);
-    }
-  }
-  return rows;
-};
-var executeWithEntityContext = async (entityCtx, qb) => {
-  const ast = qb.getAST();
-  const compiled = entityCtx.dialect.compileSelect(ast);
-  const executed = await entityCtx.executor.executeSql(compiled.sql, compiled.params);
-  const rows = flattenResults(executed);
-  if (ast.setOps && ast.setOps.length > 0) {
-    return rows.map((row) => createEntityProxy(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
-  }
-  const hydrated = hydrateRows(rows, qb.getHydrationPlan());
-  return hydrated.map((row) => createEntityFromRow(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
-};
-async function executeHydrated(session, qb) {
-  return executeWithEntityContext(session, qb);
-}
-async function executeHydratedWithContexts(_execCtx, hydCtx, qb) {
-  const entityCtx = hydCtx.entityContext;
-  if (!entityCtx) {
-    throw new Error("Hydration context is missing an EntityContext");
-  }
-  return executeWithEntityContext(entityCtx, qb);
-}
-
-// src/query-builder/select.ts
-var SelectQueryBuilder = class _SelectQueryBuilder {
-  /**
-  
-     * Creates a new SelectQueryBuilder instance
-  
-     * @param table - Table definition to query
-  
-     * @param state - Optional initial query state
-  
-     * @param hydration - Optional hydration manager
-  
-     * @param dependencies - Optional query builder dependencies
-  
-     */
-  constructor(table, state, hydration, dependencies, lazyRelations) {
-    const deps = resolveSelectQueryBuilderDependencies(dependencies);
-    this.env = { table, deps };
-    const initialState = state ?? deps.createState(table);
-    const initialHydration = hydration ?? deps.createHydration(table);
-    this.context = {
-      state: initialState,
-      hydration: initialHydration
-    };
-    this.lazyRelations = new Set(lazyRelations ?? []);
-    this.columnSelector = new ColumnSelector(this.env);
-    this.relationManager = new RelationManager(this.env);
-  }
-  clone(context = this.context, lazyRelations = new Set(this.lazyRelations)) {
-    return new _SelectQueryBuilder(this.env.table, context.state, context.hydration, this.env.deps, lazyRelations);
-  }
-  /**
-   * Applies an alias to the root FROM table.
-   * @param alias - Alias to apply
-   */
-  as(alias) {
-    const from = this.context.state.ast.from;
-    if (from.type !== "Table") {
-      throw new Error("Cannot alias non-table FROM sources");
-    }
-    const nextFrom = { ...from, alias };
-    const nextContext = this.applyAst(this.context, (service) => service.withFrom(nextFrom));
-    return this.clone(nextContext);
-  }
-  resolveQueryNode(query) {
-    return typeof query.getAST === "function" ? query.getAST() : query;
-  }
-  applyCorrelation(ast, correlation) {
-    if (!correlation) return ast;
-    const combinedWhere = ast.where ? and(correlation, ast.where) : correlation;
-    return {
-      ...ast,
-      where: combinedWhere
-    };
-  }
-  createChildBuilder(table) {
-    return new _SelectQueryBuilder(table, void 0, void 0, this.env.deps);
-  }
-  applyAst(context, mutator) {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = mutator(astService);
-    return { state: nextState, hydration: context.hydration };
-  }
-  applyJoin(context, table, condition, kind) {
-    const joinNode = createJoinNode(kind, table.name, condition);
-    return this.applyAst(context, (service) => service.withJoin(joinNode));
-  }
-  applySetOperation(operator, query) {
-    const subAst = this.resolveQueryNode(query);
-    return this.applyAst(this.context, (service) => service.withSetOperation(operator, subAst));
-  }
-  /**
-  
-     * Selects specific columns for the query
-  
-     * @param columns - Record of column definitions, function nodes, case expressions, or window functions
-  
-     * @returns New query builder instance with selected columns
-  
-     */
-  select(columns) {
-    return this.clone(this.columnSelector.select(this.context, columns));
-  }
-  /**
-   * Selects columns from the root table by name (typed).
-   * @param cols - Column names on the root table
-   */
-  selectColumns(...cols) {
-    const selection = {};
-    for (const key of cols) {
-      const col = this.env.table.columns[key];
-      if (!col) {
-        throw new Error(`Column '${key}' not found on table '${this.env.table.name}'`);
-      }
-      selection[key] = col;
-    }
-    return this.select(selection);
-  }
-  /**
-  
-     * Selects raw column expressions
-  
-     * @param cols - Column expressions as strings
-  
-     * @returns New query builder instance with raw column selections
-  
-     */
-  selectRaw(...cols) {
-    return this.clone(this.columnSelector.selectRaw(this.context, cols));
-  }
-  /**
-  
-     * Adds a Common Table Expression (CTE) to the query
-  
-     * @param name - Name of the CTE
-  
-     * @param query - Query builder or query node for the CTE
-  
-     * @param columns - Optional column names for the CTE
-  
-     * @returns New query builder instance with the CTE
-  
-     */
-  with(name, query, columns) {
-    const subAst = this.resolveQueryNode(query);
-    const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, false));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds a recursive Common Table Expression (CTE) to the query
-  
-     * @param name - Name of the CTE
-  
-     * @param query - Query builder or query node for the CTE
-  
-     * @param columns - Optional column names for the CTE
-  
-     * @returns New query builder instance with the recursive CTE
-  
-     */
-  withRecursive(name, query, columns) {
-    const subAst = this.resolveQueryNode(query);
-    const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, true));
-    return this.clone(nextContext);
-  }
-  /**
-   * Replaces the FROM clause with a derived table (subquery with alias)
-   * @param subquery - Subquery to use as the FROM source
-   * @param alias - Alias for the derived table
-   * @param columnAliases - Optional column alias list
-   * @returns New query builder instance with updated FROM
-   */
-  fromSubquery(subquery, alias, columnAliases) {
-    const subAst = this.resolveQueryNode(subquery);
-    const fromNode = derivedTable(subAst, alias, columnAliases);
-    const nextContext = this.applyAst(this.context, (service) => service.withFrom(fromNode));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Selects a subquery as a column
-  
-     * @param alias - Alias for the subquery column
-  
-     * @param sub - Query builder or query node for the subquery
-  
-     * @returns New query builder instance with the subquery selection
-  
-     */
-  selectSubquery(alias, sub) {
-    const query = this.resolveQueryNode(sub);
-    return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
-  }
-  /**
-   * Adds a JOIN against a derived table (subquery with alias)
-   * @param subquery - Subquery to join
-   * @param alias - Alias for the derived table
-   * @param condition - Join condition expression
-   * @param joinKind - Join kind (defaults to INNER)
-   * @param columnAliases - Optional column alias list for the derived table
-   * @returns New query builder instance with the derived-table join
-   */
-  joinSubquery(subquery, alias, condition, joinKind = JOIN_KINDS.INNER, columnAliases) {
-    const subAst = this.resolveQueryNode(subquery);
-    const joinNode = createJoinNode(joinKind, derivedTable(subAst, alias, columnAliases), condition);
-    const nextContext = this.applyAst(this.context, (service) => service.withJoin(joinNode));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds an INNER JOIN to the query
-  
-     * @param table - Table to join
-  
-     * @param condition - Join condition expression
-  
-     * @returns New query builder instance with the INNER JOIN
-  
-     */
-  innerJoin(table, condition) {
-    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.INNER);
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds a LEFT JOIN to the query
-  
-     * @param table - Table to join
-  
-     * @param condition - Join condition expression
-  
-     * @returns New query builder instance with the LEFT JOIN
-  
-     */
-  leftJoin(table, condition) {
-    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.LEFT);
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds a RIGHT JOIN to the query
-  
-     * @param table - Table to join
-  
-     * @param condition - Join condition expression
-  
-     * @returns New query builder instance with the RIGHT JOIN
-  
-     */
-  rightJoin(table, condition) {
-    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.RIGHT);
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Matches records based on a relationship
-  
-     * @param relationName - Name of the relationship to match
-  
-     * @param predicate - Optional predicate expression
-  
-     * @returns New query builder instance with the relationship match
-  
-     */
-  match(relationName, predicate) {
-    const nextContext = this.relationManager.match(this.context, relationName, predicate);
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Joins a related table
-  
-     * @param relationName - Name of the relationship to join
-  
-     * @param joinKind - Type of join (defaults to INNER)
-  
-     * @param extraCondition - Optional additional join condition
-  
-     * @returns New query builder instance with the relationship join
-  
-     */
-  joinRelation(relationName, joinKind = JOIN_KINDS.INNER, extraCondition) {
-    const nextContext = this.relationManager.joinRelation(this.context, relationName, joinKind, extraCondition);
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Includes related data in the query results
-  
-     * @param relationName - Name of the relationship to include
-  
-     * @param options - Optional include options
-  
-     * @returns New query builder instance with the relationship inclusion
-  
-     */
-  include(relationName, options) {
-    const nextContext = this.relationManager.include(this.context, relationName, options);
-    return this.clone(nextContext);
-  }
-  includeLazy(relationName) {
-    const nextLazy = new Set(this.lazyRelations);
-    nextLazy.add(relationName);
-    return this.clone(this.context, nextLazy);
-  }
-  /**
-   * Selects columns for a related table in a single hop.
-   */
-  selectRelationColumns(relationName, ...cols) {
-    const relation = this.env.table.relations[relationName];
-    if (!relation) {
-      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
-    }
-    const target = relation.target;
-    for (const col of cols) {
-      if (!target.columns[col]) {
-        throw new Error(
-          `Column '${col}' not found on related table '${target.name}' for relation '${relationName}'`
-        );
-      }
-    }
-    return this.include(relationName, { columns: cols });
-  }
-  /**
-   * Convenience alias for selecting specific columns from a relation.
-   */
-  includePick(relationName, cols) {
-    return this.selectRelationColumns(relationName, ...cols);
-  }
-  /**
-   * Selects columns for the root table and relations from a single config object.
-   */
-  selectColumnsDeep(config) {
-    let qb = this;
-    if (config.root?.length) {
-      qb = qb.selectColumns(...config.root);
-    }
-    for (const key of Object.keys(config)) {
-      if (key === "root") continue;
-      const relName = key;
-      const cols = config[relName];
-      if (!cols || !cols.length) continue;
-      qb = qb.selectRelationColumns(relName, ...cols);
-    }
-    return qb;
-  }
-  getLazyRelations() {
-    return Array.from(this.lazyRelations);
-  }
-  getTable() {
-    return this.env.table;
-  }
-  async execute(ctx) {
-    return executeHydrated(ctx, this);
-  }
-  async executeWithContexts(execCtx, hydCtx) {
-    return executeHydratedWithContexts(execCtx, hydCtx, this);
-  }
-  /**
-  
-     * Adds a WHERE condition to the query
-  
-     * @param expr - Expression for the WHERE clause
-  
-     * @returns New query builder instance with the WHERE condition
-  
-     */
-  where(expr) {
-    const nextContext = this.applyAst(this.context, (service) => service.withWhere(expr));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds a GROUP BY clause to the query
-  
-     * @param col - Column definition or column node to group by
-  
-     * @returns New query builder instance with the GROUP BY clause
-  
-     */
-  groupBy(col) {
-    const nextContext = this.applyAst(this.context, (service) => service.withGroupBy(col));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds a HAVING condition to the query
-  
-     * @param expr - Expression for the HAVING clause
-  
-     * @returns New query builder instance with the HAVING condition
-  
-     */
-  having(expr) {
-    const nextContext = this.applyAst(this.context, (service) => service.withHaving(expr));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds an ORDER BY clause to the query
-  
-     * @param col - Column definition or column node to order by
-  
-     * @param direction - Order direction (defaults to ASC)
-  
-     * @returns New query builder instance with the ORDER BY clause
-  
-     */
-  orderBy(col, direction = ORDER_DIRECTIONS.ASC) {
-    const nextContext = this.applyAst(this.context, (service) => service.withOrderBy(col, direction));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds a DISTINCT clause to the query
-  
-     * @param cols - Columns to make distinct
-  
-     * @returns New query builder instance with the DISTINCT clause
-  
-     */
-  distinct(...cols) {
-    return this.clone(this.columnSelector.distinct(this.context, cols));
-  }
-  /**
-  
-     * Adds a LIMIT clause to the query
-  
-     * @param n - Maximum number of rows to return
-  
-     * @returns New query builder instance with the LIMIT clause
-  
-     */
-  limit(n) {
-    const nextContext = this.applyAst(this.context, (service) => service.withLimit(n));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Adds an OFFSET clause to the query
-  
-     * @param n - Number of rows to skip
-  
-     * @returns New query builder instance with the OFFSET clause
-  
-     */
-  offset(n) {
-    const nextContext = this.applyAst(this.context, (service) => service.withOffset(n));
-    return this.clone(nextContext);
-  }
-  /**
-  
-     * Combines this query with another using UNION
-  
-     * @param query - Query to union with
-  
-     * @returns New query builder instance with the set operation
-  
-     */
-  union(query) {
-    return this.clone(this.applySetOperation("UNION", query));
-  }
-  /**
-  
-     * Combines this query with another using UNION ALL
-  
-     * @param query - Query to union with
-  
-     * @returns New query builder instance with the set operation
-  
-     */
-  unionAll(query) {
-    return this.clone(this.applySetOperation("UNION ALL", query));
-  }
-  /**
-  
-     * Combines this query with another using INTERSECT
-  
-     * @param query - Query to intersect with
-  
-     * @returns New query builder instance with the set operation
-  
-     */
-  intersect(query) {
-    return this.clone(this.applySetOperation("INTERSECT", query));
-  }
-  /**
-  
-     * Combines this query with another using EXCEPT
-  
-     * @param query - Query to subtract
-  
-     * @returns New query builder instance with the set operation
-  
-     */
-  except(query) {
-    return this.clone(this.applySetOperation("EXCEPT", query));
-  }
-  /**
-  
-     * Adds a WHERE EXISTS condition to the query
-  
-     * @param subquery - Subquery to check for existence
-  
-     * @returns New query builder instance with the WHERE EXISTS condition
-  
-     */
-  whereExists(subquery, correlate) {
-    const subAst = this.resolveQueryNode(subquery);
-    const correlated = this.applyCorrelation(subAst, correlate);
-    return this.where(exists(correlated));
-  }
-  /**
-  
-     * Adds a WHERE NOT EXISTS condition to the query
-  
-     * @param subquery - Subquery to check for non-existence
-  
-     * @returns New query builder instance with the WHERE NOT EXISTS condition
-  
-     */
-  whereNotExists(subquery, correlate) {
-    const subAst = this.resolveQueryNode(subquery);
-    const correlated = this.applyCorrelation(subAst, correlate);
-    return this.where(notExists(correlated));
-  }
-  /**
-  
-     * Adds a WHERE EXISTS condition based on a relationship
-  
-     * @param relationName - Name of the relationship to check
-  
-     * @param callback - Optional callback to modify the relationship query
-  
-     * @returns New query builder instance with the relationship existence check
-  
-     */
-  whereHas(relationName, callbackOrOptions, maybeOptions) {
-    const relation = this.env.table.relations[relationName];
-    if (!relation) {
-      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
-    }
-    const callback = typeof callbackOrOptions === "function" ? callbackOrOptions : void 0;
-    const options = typeof callbackOrOptions === "function" ? maybeOptions : callbackOrOptions;
-    let subQb = this.createChildBuilder(relation.target);
-    if (callback) {
-      subQb = callback(subQb);
-    }
-    const subAst = subQb.getAST();
-    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst, options?.correlate);
-    return this.where(exists(finalSubAst));
-  }
-  /**
-  
-     * Adds a WHERE NOT EXISTS condition based on a relationship
-  
-     * @param relationName - Name of the relationship to check
-  
-     * @param callback - Optional callback to modify the relationship query
-  
-     * @returns New query builder instance with the relationship non-existence check
-  
-     */
-  whereHasNot(relationName, callbackOrOptions, maybeOptions) {
-    const relation = this.env.table.relations[relationName];
-    if (!relation) {
-      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
-    }
-    const callback = typeof callbackOrOptions === "function" ? callbackOrOptions : void 0;
-    const options = typeof callbackOrOptions === "function" ? maybeOptions : callbackOrOptions;
-    let subQb = this.createChildBuilder(relation.target);
-    if (callback) {
-      subQb = callback(subQb);
-    }
-    const subAst = subQb.getAST();
-    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst, options?.correlate);
-    return this.where(notExists(finalSubAst));
-  }
-  /**
-  
-     * Compiles the query to SQL for a specific dialect
-  
-     * @param dialect - Database dialect to compile for
-  
-     * @returns Compiled query with SQL and parameters
-  
-     */
-  compile(dialect) {
-    const resolved = resolveDialectInput(dialect);
-    return resolved.compileSelect(this.context.state.ast);
-  }
-  /**
-  
-     * Converts the query to SQL string for a specific dialect
-  
-     * @param dialect - Database dialect to generate SQL for
-  
-     * @returns SQL string representation of the query
-  
-     */
-  toSql(dialect) {
-    return this.compile(dialect).sql;
-  }
-  /**
-  
-     * Gets the hydration plan for the query
-  
-     * @returns Hydration plan or undefined if none exists
-  
-     */
-  getHydrationPlan() {
-    return this.context.hydration.getPlan();
-  }
-  /**
-  
-     * Gets the Abstract Syntax Tree (AST) representation of the query
-  
-     * @returns Query AST with hydration applied
-  
-     */
-  getAST() {
-    return this.context.hydration.applyToAst(this.context.state.ast);
-  }
-};
-
-// src/decorators/bootstrap.ts
-var isTableDef = (value) => {
-  return typeof value === "object" && value !== null && "columns" in value;
-};
-var unwrapTarget = (target) => {
-  if (typeof target === "function" && target.prototype === void 0) {
-    return target();
-  }
-  return target;
-};
-var resolveTableTarget = (target, tableMap) => {
-  const resolved = unwrapTarget(target);
-  if (isTableDef(resolved)) {
-    return resolved;
-  }
-  const table = tableMap.get(resolved);
-  if (!table) {
-    throw new Error(`Entity '${resolved.name}' is not registered with decorators`);
-  }
-  return table;
-};
-var buildRelationDefinitions = (meta, tableMap) => {
-  const relations = {};
-  for (const [name, relation] of Object.entries(meta.relations)) {
-    switch (relation.kind) {
-      case RelationKinds.HasOne: {
-        relations[name] = hasOne(
-          resolveTableTarget(relation.target, tableMap),
-          relation.foreignKey,
-          relation.localKey,
-          relation.cascade
-        );
-        break;
-      }
-      case RelationKinds.HasMany: {
-        relations[name] = hasMany(
-          resolveTableTarget(relation.target, tableMap),
-          relation.foreignKey,
-          relation.localKey,
-          relation.cascade
-        );
-        break;
-      }
-      case RelationKinds.BelongsTo: {
-        relations[name] = belongsTo(
-          resolveTableTarget(relation.target, tableMap),
-          relation.foreignKey,
-          relation.localKey,
-          relation.cascade
-        );
-        break;
-      }
-      case RelationKinds.BelongsToMany: {
-        relations[name] = belongsToMany(
-          resolveTableTarget(relation.target, tableMap),
-          resolveTableTarget(relation.pivotTable, tableMap),
-          {
-            pivotForeignKeyToRoot: relation.pivotForeignKeyToRoot,
-            pivotForeignKeyToTarget: relation.pivotForeignKeyToTarget,
-            localKey: relation.localKey,
-            targetKey: relation.targetKey,
-            pivotPrimaryKey: relation.pivotPrimaryKey,
-            defaultPivotColumns: relation.defaultPivotColumns,
-            cascade: relation.cascade
-          }
-        );
-        break;
-      }
-    }
-  }
-  return relations;
-};
-var bootstrapEntities = () => {
-  const metas = getAllEntityMetadata();
-  const tableMap = /* @__PURE__ */ new Map();
-  for (const meta of metas) {
-    const table = buildTableDef(meta);
-    tableMap.set(meta.target, table);
-  }
-  for (const meta of metas) {
-    const table = meta.table;
-    const relations = buildRelationDefinitions(meta, tableMap);
-    table.relations = relations;
-  }
-  return metas.map((meta) => meta.table);
-};
-var getTableDefFromEntity = (ctor) => {
-  const meta = getEntityMetadata(ctor);
-  if (!meta) return void 0;
-  if (!meta.table) {
-    bootstrapEntities();
-  }
-  return meta.table;
-};
-var selectFromEntity = (ctor) => {
-  const table = getTableDefFromEntity(ctor);
-  if (!table) {
-    throw new Error(`Entity '${ctor.name}' is not registered with decorators or has not been bootstrapped`);
-  }
-  return new SelectQueryBuilder(table);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BelongsTo,
-  BelongsToMany,
-  Column,
-  Entity,
-  HasMany,
-  HasOne,
-  PrimaryKey,
-  bootstrapEntities,
-  getTableDefFromEntity,
-  selectFromEntity
-});
-//# sourceMappingURL=index.cjs.map