prisma-sql 1.3.0 → 1.4.0

package/dist/generator.cjs

@@ -0,0 +1,4657 @@
+'use strict';
+
+var generatorHelper = require('@prisma/generator-helper');
+var schemaParser = require('@dee-wan/schema-parser');
+var promises = require('fs/promises');
+var path = require('path');
+var internals = require('@prisma/internals');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports$1, module) {
+    module.exports = {
+      name: "prisma-sql",
+      version: "1.4.0",
+      description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
+      main: "dist/index.cjs",
+      module: "dist/index.js",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js",
+          require: "./dist/index.cjs"
+        },
+        "./generator": {
+          types: "./dist/generator.d.ts",
+          import: "./dist/generator.js",
+          require: "./dist/generator.cjs"
+        }
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE"
+      ],
+      scripts: {
+        build: "tsup",
+        test: "vitest",
+        "test:coverage": "vitest --coverage",
+        "test:e2e": "vitest run tests/e2e",
+        bench: "npx tsx tests/helpers/run-benchmarks.ts",
+        "prisma:generate": "npx prisma generate --schema=tests/prisma/schema.prisma",
+        "prisma:migrate": "npx prisma migrate dev --schema=tests/prisma/schema.prisma",
+        "prisma:reset": "npx prisma db push --force-reset --skip-generate --schema=tests/prisma/schema.prisma",
+        prepublishOnly: "npm run build",
+        "sonar-cli": "sonar-scanner   -Dsonar.projectKey=prisma-sql   -Dsonar.sources=./src   -Dsonar.host.url=http://localhost:9000   -Dsonar.login=sqp_9fe07460d0aa83f711d0edf4f317f05019d0613b",
+        sonar: "yarn sonar-cli && npx tsx scripts/sonar.ts"
+      },
+      keywords: [
+        "prisma",
+        "sql",
+        "query",
+        "optimizer",
+        "postgresql",
+        "sqlite",
+        "cloudflare",
+        "d1",
+        "performance",
+        "typescript",
+        "generator"
+      ],
+      repository: {
+        type: "git",
+        url: "https://github.com/multipliedtwice/prisma-to-sql.git"
+      },
+      bugs: {
+        url: "https://github.com/multipliedtwice/prisma-to-sql/issues"
+      },
+      homepage: "https://github.com/multipliedtwice/prisma-to-sql#readme",
+      author: "multipliedtwice <multipliedtwice@gmail.com>",
+      license: "MIT",
+      dependencies: {
+        "@dee-wan/schema-parser": "1.1.0",
+        "@prisma/generator-helper": "^7.2.0",
+        "@prisma/internals": "^7.2.0"
+      },
+      devDependencies: {
+        "@faker-js/faker": "^10.2.0",
+        "@prisma/adapter-better-sqlite3": "^7.2.0",
+        "@prisma/adapter-pg": "^7.2.0",
+        "@prisma/client": "7.2.0",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/node": "^20.0.0",
+        "better-sqlite3": "^12.6.2",
+        "drizzle-kit": "^0.31.8",
+        "drizzle-orm": "^0.45.1",
+        postgres: "^3.4.8",
+        prisma: "7.2.0",
+        tsup: "^8.5.1",
+        tsx: "^4.7.0",
+        typescript: "^5.3.3",
+        vitest: "^4.0.14"
+      },
+      peerDependencies: {
+        "@prisma/client": ">=4.0.0"
+      },
+      peerDependenciesMeta: {
+        "@prisma/client": {
+          optional: false
+        }
+      },
+      engines: {
+        node: ">=16.0.0"
+      }
+    };
+  }
+});
+
+// src/sql-builder-dialect.ts
+var globalDialect = "postgres";
+function setGlobalDialect(dialect) {
+  if (dialect !== "postgres" && dialect !== "sqlite") {
+    throw new Error(
+      `Invalid dialect: ${dialect}. Must be 'postgres' or 'sqlite'`
+    );
+  }
+  globalDialect = dialect;
+}
+function getGlobalDialect() {
+  return globalDialect;
+}
+function assertNonEmpty(value, name) {
+  if (!value || value.trim().length === 0) {
+    throw new Error(`${name} is required and cannot be empty`);
+  }
+}
+function arrayContains(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayContains column");
+  assertNonEmpty(value, "arrayContains value");
+  if (dialect === "postgres") {
+    return `${column} @> ARRAY[${value}]::${arrayType}`;
+  }
+  return `EXISTS (SELECT 1 FROM json_each(${column}) WHERE value = ${value})`;
+}
+function arrayOverlaps(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayOverlaps column");
+  assertNonEmpty(value, "arrayOverlaps value");
+  if (dialect === "postgres") {
+    return `${column} && ${value}::${arrayType}`;
+  }
+  return `EXISTS (
+    SELECT 1 FROM json_each(${column}) AS col
+    JOIN json_each(${value}) AS val
+    WHERE col.value = val.value
+  )`;
+}
+function arrayContainsAll(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayContainsAll column");
+  assertNonEmpty(value, "arrayContainsAll value");
+  if (dialect === "postgres") {
+    return `${column} @> ${value}::${arrayType}`;
+  }
+  return `NOT EXISTS (
+    SELECT 1 FROM json_each(${value}) AS val
+    WHERE NOT EXISTS (
+      SELECT 1 FROM json_each(${column}) AS col
+      WHERE col.value = val.value
+    )
+  )`;
+}
+function arrayIsEmpty(column, dialect) {
+  assertNonEmpty(column, "arrayIsEmpty column");
+  if (dialect === "postgres") {
+    return `(${column} IS NULL OR array_length(${column}, 1) IS NULL)`;
+  }
+  return `(${column} IS NULL OR json_array_length(${column}) = 0)`;
+}
+function arrayIsNotEmpty(column, dialect) {
+  assertNonEmpty(column, "arrayIsNotEmpty column");
+  if (dialect === "postgres") {
+    return `(${column} IS NOT NULL AND array_length(${column}, 1) IS NOT NULL)`;
+  }
+  return `(${column} IS NOT NULL AND json_array_length(${column}) > 0)`;
+}
+function arrayEquals(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayEquals column");
+  assertNonEmpty(value, "arrayEquals value");
+  if (dialect === "postgres") {
+    return `${column} = ${value}::${arrayType}`;
+  }
+  return `json(${column}) = json(${value})`;
+}
+function caseInsensitiveLike(column, pattern, dialect) {
+  assertNonEmpty(column, "caseInsensitiveLike column");
+  assertNonEmpty(pattern, "caseInsensitiveLike pattern");
+  if (dialect === "postgres") {
+    return `${column} ILIKE ${pattern}`;
+  }
+  return `LOWER(${column}) LIKE LOWER(${pattern})`;
+}
+function caseInsensitiveEquals(column, value, dialect) {
+  assertNonEmpty(column, "caseInsensitiveEquals column");
+  assertNonEmpty(value, "caseInsensitiveEquals value");
+  return `LOWER(${column}) = LOWER(${value})`;
+}
+function jsonExtractText(column, path, dialect) {
+  assertNonEmpty(column, "jsonExtractText column");
+  assertNonEmpty(path, "jsonExtractText path");
+  if (dialect === "postgres") {
+    const p = String(path).trim();
+    const pathExpr = /^\$\d+$/.test(p) ? `${p}::text[]` : p;
+    return `${column}#>>${pathExpr}`;
+  }
+  return `json_extract(${column}, ${path})`;
+}
+function jsonExtractNumeric(column, path, dialect) {
+  assertNonEmpty(column, "jsonExtractNumeric column");
+  assertNonEmpty(path, "jsonExtractNumeric path");
+  if (dialect === "postgres") {
+    const p = String(path).trim();
+    const pathExpr = /^\$\d+$/.test(p) ? `${p}::text[]` : p;
+    return `(${column}#>>${pathExpr})::numeric`;
+  }
+  return `CAST(json_extract(${column}, ${path}) AS REAL)`;
+}
+function jsonToText(column, dialect) {
+  assertNonEmpty(column, "jsonToText column");
+  if (dialect === "postgres") {
+    return `${column}::text`;
+  }
+  return column;
+}
+function inArray(column, value, dialect) {
+  assertNonEmpty(column, "inArray column");
+  assertNonEmpty(value, "inArray value");
+  if (dialect === "postgres") {
+    return `${column} = ANY(${value})`;
+  }
+  return `${column} IN (SELECT value FROM json_each(${value}))`;
+}
+function notInArray(column, value, dialect) {
+  assertNonEmpty(column, "notInArray column");
+  assertNonEmpty(value, "notInArray value");
+  if (dialect === "postgres") {
+    return `${column} != ALL(${value})`;
+  }
+  return `${column} NOT IN (SELECT value FROM json_each(${value}))`;
+}
+function getArrayType(prismaType, dialect) {
+  if (!prismaType || prismaType.length === 0) {
+    return dialect === "sqlite" ? "TEXT" : "text[]";
+  }
+  if (dialect === "sqlite") {
+    return "TEXT";
+  }
+  const baseType = prismaType.replace(/\[\]|\?/g, "");
+  switch (baseType) {
+    case "String":
+      return "text[]";
+    case "Int":
+      return "integer[]";
+    case "Float":
+      return "double precision[]";
+    case "Decimal":
+      return "numeric[]";
+    case "Boolean":
+      return "boolean[]";
+    case "BigInt":
+      return "bigint[]";
+    case "DateTime":
+      return "timestamptz[]";
+    default:
+      return "text[]";
+  }
+}
+function jsonAgg(content, dialect) {
+  assertNonEmpty(content, "jsonAgg content");
+  if (dialect === "postgres") {
+    return `json_agg(${content})`;
+  }
+  return `json_group_array(${content})`;
+}
+function jsonBuildObject(pairs, dialect) {
+  const safePairs = (pairs != null ? pairs : "").trim();
+  if (dialect === "postgres") {
+    return safePairs.length > 0 ? `json_build_object(${safePairs})` : `json_build_object()`;
+  }
+  return safePairs.length > 0 ? `json_object(${safePairs})` : `json_object()`;
+}
+function prepareArrayParam(value, dialect) {
+  if (!Array.isArray(value)) {
+    throw new Error("prepareArrayParam requires array value");
+  }
+  if (dialect === "postgres") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+// src/builder/shared/constants.ts
+var SQL_SEPARATORS = Object.freeze({
+  FIELD_LIST: ", ",
+  CONDITION_AND: " AND ",
+  CONDITION_OR: " OR ",
+  ORDER_BY: ", "
+});
+var SQL_RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "select",
+  "from",
+  "where",
+  "and",
+  "or",
+  "not",
+  "in",
+  "like",
+  "between",
+  "order",
+  "by",
+  "group",
+  "having",
+  "limit",
+  "offset",
+  "join",
+  "inner",
+  "left",
+  "right",
+  "outer",
+  "on",
+  "as",
+  "table",
+  "column",
+  "index",
+  "user",
+  "users",
+  "values",
+  "update",
+  "insert",
+  "delete",
+  "create",
+  "drop",
+  "alter",
+  "truncate",
+  "grant",
+  "revoke",
+  "exec",
+  "execute",
+  "union",
+  "intersect",
+  "except",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  "null",
+  "true",
+  "false",
+  "is",
+  "exists",
+  "all",
+  "any",
+  "some"
+]);
+var SQL_KEYWORDS = SQL_RESERVED_WORDS;
+var DEFAULT_WHERE_CLAUSE = "1=1";
+var SPECIAL_FIELDS = Object.freeze({
+  ID: "id"
+});
+var SQL_TEMPLATES = Object.freeze({
+  PUBLIC_SCHEMA: "public",
+  WHERE: "WHERE",
+  SELECT: "SELECT",
+  FROM: "FROM",
+  ORDER_BY: "ORDER BY",
+  GROUP_BY: "GROUP BY",
+  HAVING: "HAVING",
+  LIMIT: "LIMIT",
+  OFFSET: "OFFSET",
+  COUNT_ALL: "COUNT(*)",
+  AS: "AS",
+  DISTINCT_ON: "DISTINCT ON",
+  IS_NULL: "IS NULL",
+  IS_NOT_NULL: "IS NOT NULL",
+  LIKE: "LIKE",
+  AND: "AND",
+  OR: "OR",
+  NOT: "NOT"
+});
+var SCHEMA_PREFIXES = Object.freeze({
+  INTERNAL: "@",
+  COMMENT: "//"
+});
+var Ops = Object.freeze({
+  EQUALS: "equals",
+  NOT: "not",
+  GT: "gt",
+  GTE: "gte",
+  LT: "lt",
+  LTE: "lte",
+  IN: "in",
+  NOT_IN: "notIn",
+  CONTAINS: "contains",
+  STARTS_WITH: "startsWith",
+  ENDS_WITH: "endsWith",
+  HAS: "has",
+  HAS_SOME: "hasSome",
+  HAS_EVERY: "hasEvery",
+  IS_EMPTY: "isEmpty",
+  PATH: "path",
+  STRING_CONTAINS: "string_contains",
+  STRING_STARTS_WITH: "string_starts_with",
+  STRING_ENDS_WITH: "string_ends_with"
+});
+var LogicalOps = Object.freeze({
+  AND: "AND",
+  OR: "OR",
+  NOT: "NOT"
+});
+var RelationFilters = Object.freeze({
+  SOME: "some",
+  EVERY: "every",
+  NONE: "none"
+});
+var Modes = Object.freeze({
+  INSENSITIVE: "insensitive",
+  DEFAULT: "default"
+});
+var Wildcards = Object.freeze({
+  [Ops.CONTAINS]: (v) => `%${v}%`,
+  [Ops.STARTS_WITH]: (v) => `${v}%`,
+  [Ops.ENDS_WITH]: (v) => `%${v}`
+});
+var REGEX_CACHE = {
+  VALID_IDENTIFIER: /^[a-z_][a-z0-9_]*$/
+};
+var LIMITS = Object.freeze({
+  MAX_QUERY_DEPTH: 50,
+  MAX_ARRAY_SIZE: 1e4,
+  MAX_STRING_LENGTH: 1e4
+});
+
+// src/builder/shared/validators/type-guards.ts
+function isNotNullish(value) {
+  return value !== null && value !== void 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isEmptyString(value) {
+  return typeof value === "string" && value.trim().length === 0;
+}
+function isNonEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+function isPlainObject(val) {
+  if (!isNotNullish(val)) return false;
+  if (Array.isArray(val)) return false;
+  if (typeof val !== "object") return false;
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+function hasProperty(obj, key) {
+  return isPlainObject(obj) && key in obj;
+}
+function isArrayType(t) {
+  if (!isNotNullish(t)) return false;
+  const normalized = t.replace(/\?$/, "");
+  return normalized.endsWith("[]");
+}
+function isJsonType(t) {
+  return isNotNullish(t) && (t === "Json" || t === "Json?");
+}
+function hasValidContent(sql) {
+  return isNotNullish(sql) && sql.trim().length > 0;
+}
+function hasRequiredKeywords(sql) {
+  const upper = sql.toUpperCase();
+  const hasSelect = upper.includes("SELECT");
+  const hasFrom = upper.includes("FROM");
+  return hasSelect && hasFrom && upper.indexOf("SELECT") < upper.indexOf("FROM");
+}
+
+// src/builder/shared/errors.ts
+var SqlBuilderError = class extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.name = "SqlBuilderError";
+    this.code = code;
+    this.context = context;
+  }
+};
+function createError(message, ctx, code = "VALIDATION_ERROR") {
+  const parts = [message];
+  if (isNonEmptyArray(ctx.path)) {
+    parts.push(`Path: ${ctx.path.join(".")}`);
+  }
+  if (isNotNullish(ctx.modelName)) {
+    parts.push(`Model: ${ctx.modelName}`);
+  }
+  if (isNonEmptyArray(ctx.availableFields)) {
+    parts.push(`Available fields: ${ctx.availableFields.join(", ")}`);
+  }
+  return new SqlBuilderError(parts.join("\n"), code, ctx);
+}
+
+// src/builder/shared/model-field-cache.ts
+var SCALAR_SET_CACHE = /* @__PURE__ */ new WeakMap();
+var RELATION_SET_CACHE = /* @__PURE__ */ new WeakMap();
+function getScalarFieldSet(model) {
+  const cached = SCALAR_SET_CACHE.get(model);
+  if (cached) return cached;
+  const s = /* @__PURE__ */ new Set();
+  for (const f of model.fields) if (!f.isRelation) s.add(f.name);
+  SCALAR_SET_CACHE.set(model, s);
+  return s;
+}
+function getRelationFieldSet(model) {
+  const cached = RELATION_SET_CACHE.get(model);
+  if (cached) return cached;
+  const s = /* @__PURE__ */ new Set();
+  for (const f of model.fields) if (f.isRelation) s.add(f.name);
+  RELATION_SET_CACHE.set(model, s);
+  return s;
+}
+
+// src/builder/shared/validators/sql-validators.ts
+function isValidWhereClause(clause) {
+  return isNotNullish(clause) && clause.trim().length > 0 && clause !== DEFAULT_WHERE_CLAUSE;
+}
+function isEmptyWhere(where) {
+  if (!isNotNullish(where)) return true;
+  return Object.keys(where).length === 0;
+}
+function validateSelectQuery(sql) {
+  if (!hasValidContent(sql)) {
+    throw new Error("CRITICAL: Generated empty SQL query");
+  }
+  if (!hasRequiredKeywords(sql)) {
+    throw new Error(
+      `CRITICAL: Invalid SQL structure. SQL: ${sql.substring(0, 100)}...`
+    );
+  }
+}
+function sqlPreview(sql) {
+  return `${sql.substring(0, 100)}...`;
+}
+function parseDollarNumber(sql, start, n) {
+  let i = start;
+  let num = 0;
+  let hasDigit = false;
+  while (i < n) {
+    const c = sql.charCodeAt(i);
+    if (c < 48 || c > 57) break;
+    hasDigit = true;
+    num = num * 10 + (c - 48);
+    i++;
+  }
+  if (!hasDigit || num <= 0) return { next: i, num: 0, ok: false };
+  return { next: i, num, ok: true };
+}
+function scanDollarPlaceholders(sql, markUpTo) {
+  const seen = new Uint8Array(markUpTo + 1);
+  let count = 0;
+  let min = Number.POSITIVE_INFINITY;
+  let max = 0;
+  const n = sql.length;
+  let i = 0;
+  while (i < n) {
+    if (sql.charCodeAt(i) !== 36) {
+      i++;
+      continue;
+    }
+    const { next, num, ok } = parseDollarNumber(sql, i + 1, n);
+    i = next;
+    if (!ok) continue;
+    count++;
+    if (num < min) min = num;
+    if (num > max) max = num;
+    if (num <= markUpTo) seen[num] = 1;
+  }
+  return { count, min, max, seen };
+}
+function assertNoGaps(scan, rangeMin, rangeMax, sql) {
+  for (let k = rangeMin; k <= rangeMax; k++) {
+    if (scan.seen[k] !== 1) {
+      throw new Error(
+        `CRITICAL: Parameter mismatch - SQL is missing placeholder $${k}. Placeholders must cover ${rangeMin}..${rangeMax} with no gaps. SQL: ${sqlPreview(sql)}`
+      );
+    }
+  }
+}
+function validateParamConsistency(sql, params) {
+  const paramLen = params.length;
+  if (paramLen === 0) {
+    if (sql.indexOf("$") === -1) return;
+  }
+  const scan = scanDollarPlaceholders(sql, paramLen);
+  if (scan.count === 0) {
+    if (paramLen !== 0) {
+      throw new Error(
+        `CRITICAL: Parameter mismatch - SQL has no placeholders but ${paramLen} params provided.`
+      );
+    }
+    return;
+  }
+  if (scan.max !== paramLen) {
+    throw new Error(
+      `CRITICAL: Parameter mismatch - SQL max placeholder is $${scan.max} but ${paramLen} params provided. This will cause SQL execution to fail. SQL: ${sqlPreview(sql)}`
+    );
+  }
+  assertNoGaps(scan, 1, scan.max, sql);
+}
+function needsQuoting(id) {
+  if (!isNonEmptyString(id)) return true;
+  const isKeyword = SQL_KEYWORDS.has(id.toLowerCase());
+  if (isKeyword) return true;
+  const isValidIdentifier = REGEX_CACHE.VALID_IDENTIFIER.test(id);
+  return !isValidIdentifier;
+}
+function validateParamConsistencyFragment(sql, params) {
+  const paramLen = params.length;
+  const scan = scanDollarPlaceholders(sql, paramLen);
+  if (scan.max === 0) return;
+  if (scan.max > paramLen) {
+    throw new Error(
+      `CRITICAL: Parameter mismatch - SQL references $${scan.max} but only ${paramLen} params provided. SQL: ${sqlPreview(sql)}`
+    );
+  }
+  assertNoGaps(scan, scan.min, scan.max, sql);
+}
+function assertOrThrow(condition, message) {
+  if (!condition) throw new Error(message);
+}
+function dialectPlaceholderPrefix(dialect) {
+  return dialect === "sqlite" ? "?" : "$";
+}
+function parseSqlitePlaceholderIndices(sql) {
+  const re = /\?(?:(\d+))?/g;
+  const indices = [];
+  let anonCount = 0;
+  let sawNumbered = false;
+  let sawAnonymous = false;
+  for (const m of sql.matchAll(re)) {
+    const n = m[1];
+    if (n) {
+      sawNumbered = true;
+      indices.push(parseInt(n, 10));
+    } else {
+      sawAnonymous = true;
+      anonCount += 1;
+      indices.push(anonCount);
+    }
+  }
+  return { indices, sawNumbered, sawAnonymous };
+}
+function parseDollarPlaceholderIndices(sql) {
+  const re = /\$(\d+)/g;
+  const indices = [];
+  for (const m of sql.matchAll(re)) indices.push(parseInt(m[1], 10));
+  return indices;
+}
+function getPlaceholderIndices(sql, dialect) {
+  if (dialect === "sqlite") return parseSqlitePlaceholderIndices(sql);
+  return {
+    indices: parseDollarPlaceholderIndices(sql),
+    sawNumbered: false,
+    sawAnonymous: false
+  };
+}
+function maxIndex(indices) {
+  return indices.length > 0 ? Math.max(...indices) : 0;
+}
+function ensureNoMixedSqlitePlaceholders(sawNumbered, sawAnonymous) {
+  assertOrThrow(
+    !(sawNumbered && sawAnonymous),
+    `CRITICAL: Mixed sqlite placeholders ('?' and '?NNN') are not supported.`
+  );
+}
+function ensurePlaceholderMaxMatchesMappingsLength(max, mappingsLength, dialect) {
+  assertOrThrow(
+    max === mappingsLength,
+    `CRITICAL: SQL placeholder max mismatch - max is ${dialectPlaceholderPrefix(dialect)}${max}, but mappings length is ${mappingsLength}.`
+  );
+}
+function ensureSequentialPlaceholders(placeholders, max, dialect) {
+  const prefix = dialectPlaceholderPrefix(dialect);
+  for (let i = 1; i <= max; i++) {
+    assertOrThrow(
+      placeholders.has(i),
+      `CRITICAL: Missing SQL placeholder ${prefix}${i} - placeholders must be sequential 1..${max}.`
+    );
+  }
+}
+function validateMappingIndex(mapping, max) {
+  assertOrThrow(
+    Number.isInteger(mapping.index) && mapping.index >= 1 && mapping.index <= max,
+    `CRITICAL: ParamMapping index ${mapping.index} out of range 1..${max}.`
+  );
+}
+function ensureUniqueMappingIndex(mappingIndices, index, dialect) {
+  assertOrThrow(
+    !mappingIndices.has(index),
+    `CRITICAL: Duplicate ParamMapping index ${index} - each placeholder index must map to exactly one ParamMap.`
+  );
+  mappingIndices.add(index);
+}
+function ensureMappingIndexExistsInSql(placeholders, index) {
+  assertOrThrow(
+    placeholders.has(index),
+    `CRITICAL: ParamMapping index ${index} not found in SQL placeholders.`
+  );
+}
+function validateMappingValueShape(mapping) {
+  assertOrThrow(
+    !(mapping.dynamicName !== void 0 && mapping.value !== void 0),
+    `CRITICAL: ParamMap ${mapping.index} has both dynamicName and value`
+  );
+  assertOrThrow(
+    !(mapping.dynamicName === void 0 && mapping.value === void 0),
+    `CRITICAL: ParamMap ${mapping.index} has neither dynamicName nor value`
+  );
+}
+function ensureMappingsCoverAllIndices(mappingIndices, max, dialect) {
+  const prefix = dialectPlaceholderPrefix(dialect);
+  for (let i = 1; i <= max; i++) {
+    assertOrThrow(
+      mappingIndices.has(i),
+      `CRITICAL: Missing ParamMap for placeholder ${prefix}${i} - mappings must cover 1..${max} with no gaps.`
+    );
+  }
+}
+function validateMappingsAgainstPlaceholders(mappings, placeholders, max, dialect) {
+  const mappingIndices = /* @__PURE__ */ new Set();
+  for (const mapping of mappings) {
+    validateMappingIndex(mapping, max);
+    ensureUniqueMappingIndex(mappingIndices, mapping.index);
+    ensureMappingIndexExistsInSql(placeholders, mapping.index);
+    validateMappingValueShape(mapping);
+  }
+  ensureMappingsCoverAllIndices(mappingIndices, max, dialect);
+}
+function validateSqlPositions(sql, mappings, dialect) {
+  const { indices, sawNumbered, sawAnonymous } = getPlaceholderIndices(
+    sql,
+    dialect
+  );
+  if (dialect === "sqlite") {
+    ensureNoMixedSqlitePlaceholders(sawNumbered, sawAnonymous);
+  }
+  const placeholders = new Set(indices);
+  if (placeholders.size === 0 && mappings.length === 0) return;
+  const max = maxIndex(indices);
+  ensurePlaceholderMaxMatchesMappingsLength(max, mappings.length, dialect);
+  ensureSequentialPlaceholders(placeholders, max, dialect);
+  validateMappingsAgainstPlaceholders(mappings, placeholders, max, dialect);
+}
+
+// src/builder/shared/sql-utils.ts
+var NUL = String.fromCharCode(0);
+function containsControlChars(s) {
+  return s.includes(NUL) || s.includes("\n") || s.includes("\r");
+}
+function containsUnsafeSqlFragmentChars(s) {
+  return containsControlChars(s) || s.includes(";");
+}
+function quote(id) {
+  if (isEmptyString(id)) {
+    throw new Error("quote: identifier is required and cannot be empty");
+  }
+  if (containsControlChars(id)) {
+    throw new Error(
+      `quote: identifier contains invalid characters: ${JSON.stringify(id)}`
+    );
+  }
+  if (needsQuoting(id)) {
+    return `"${id.replace(/"/g, '""')}"`;
+  }
+  return id;
+}
+function col(alias, field) {
+  if (isEmptyString(alias)) {
+    throw new Error("col: alias is required and cannot be empty");
+  }
+  if (isEmptyString(field)) {
+    throw new Error("col: field is required and cannot be empty");
+  }
+  return `${alias}.${quote(field)}`;
+}
+function sqlStringLiteral(value) {
+  if (containsControlChars(value)) {
+    throw new Error("sqlStringLiteral: value contains invalid characters");
+  }
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function buildTableReference(schemaName, tableName, dialect) {
+  if (isEmptyString(tableName)) {
+    throw new Error(
+      "buildTableReference: tableName is required and cannot be empty"
+    );
+  }
+  if (containsControlChars(tableName)) {
+    throw new Error(
+      "buildTableReference: tableName contains invalid characters"
+    );
+  }
+  const d = dialect != null ? dialect : "postgres";
+  if (d === "sqlite") {
+    return quote(tableName);
+  }
+  if (isEmptyString(schemaName)) {
+    throw new Error(
+      "buildTableReference: schemaName is required and cannot be empty"
+    );
+  }
+  if (containsControlChars(schemaName)) {
+    throw new Error(
+      "buildTableReference: schemaName contains invalid characters"
+    );
+  }
+  const safeSchema = schemaName.replace(/"/g, '""');
+  const safeTable = tableName.replace(/"/g, '""');
+  return `"${safeSchema}"."${safeTable}"`;
+}
+function assertSafeAlias(alias) {
+  const a = String(alias);
+  if (a.trim().length === 0) {
+    throw new Error("alias is required and cannot be empty");
+  }
+  if (containsUnsafeSqlFragmentChars(a)) {
+    throw new Error(`alias contains unsafe characters: ${JSON.stringify(a)}`);
+  }
+  if (!/^[A-Za-z_]\w*$/.test(a)) {
+    throw new Error(
+      `alias must be a simple identifier, got: ${JSON.stringify(a)}`
+    );
+  }
+}
+function assertSafeTableRef(tableRef) {
+  const t = String(tableRef);
+  if (t.trim().length === 0) {
+    throw new Error("tableName/tableRef is required and cannot be empty");
+  }
+  if (containsUnsafeSqlFragmentChars(t)) {
+    throw new Error(
+      `tableName/tableRef contains unsafe characters: ${JSON.stringify(t)}`
+    );
+  }
+}
+function normalizeKeyList(input) {
+  if (!isNotNullish(input)) return [];
+  if (Array.isArray(input)) {
+    const out = [];
+    for (const v of input) {
+      const s2 = String(v).trim();
+      if (s2.length > 0) out.push(s2);
+    }
+    return out;
+  }
+  if (typeof input === "string") {
+    const raw = input.trim();
+    if (raw.length === 0) return [];
+    if (raw.includes(",")) {
+      return raw.split(",").map((s2) => s2.trim()).filter((s2) => s2.length > 0);
+    }
+    return [raw];
+  }
+  const s = String(input).trim();
+  return s.length > 0 ? [s] : [];
+}
+
+// src/builder/joins.ts
+function isRelationField(fieldName, model) {
+  return getRelationFieldSet(model).has(fieldName);
+}
+function isValidRelationField(field) {
+  if (!isNotNullish(field)) return false;
+  if (!field.isRelation) return false;
+  if (!isNotNullish(field.relatedModel) || field.relatedModel.trim().length === 0)
+    return false;
+  const fk = normalizeKeyList(field.foreignKey);
+  if (fk.length === 0) return false;
+  const refsRaw = field.references;
+  const refs = normalizeKeyList(refsRaw);
+  if (refs.length === 0) return false;
+  if (refs.length !== fk.length) return false;
+  return true;
+}
+function getReferenceFieldNames(field, foreignKeyCount) {
+  const refsRaw = field.references;
+  const refs = normalizeKeyList(refsRaw);
+  if (refs.length === 0) {
+    if (foreignKeyCount === 1) return [SPECIAL_FIELDS.ID];
+    return [];
+  }
+  if (refs.length !== foreignKeyCount) return [];
+  return refs;
+}
+function joinCondition(field, parentAlias, childAlias) {
+  const fkFields = normalizeKeyList(field.foreignKey);
+  if (fkFields.length === 0) {
+    throw createError(
+      `Relation '${field.name}' is missing foreignKey. This indicates a schema parsing error. Relations must specify fields/references.`,
+      { field: field.name }
+    );
+  }
+  const refFields = getReferenceFieldNames(field, fkFields.length);
+  if (refFields.length !== fkFields.length) {
+    throw createError(
+      `Relation '${field.name}' is missing references (or references count does not match foreignKey count). This is required to support non-id and composite keys.`,
+      { field: field.name }
+    );
+  }
+  const parts = [];
+  for (let i = 0; i < fkFields.length; i++) {
+    const fk = fkFields[i];
+    const ref = refFields[i];
+    const left = field.isForeignKeyLocal ? `${childAlias}.${quote(ref)}` : `${childAlias}.${quote(fk)}`;
+    const right = field.isForeignKeyLocal ? `${parentAlias}.${quote(fk)}` : `${parentAlias}.${quote(ref)}`;
+    parts.push(`${left} = ${right}`);
+  }
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function getModelByName(schemas, name) {
+  return schemas.find((m) => m.name === name);
+}
+function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
+  const entries = Object.entries(val).filter(
+    ([k, v]) => k !== "mode" && v !== void 0
+  );
+  if (entries.length === 0) return "";
+  const clauses = [];
+  for (const [subOp, subVal] of entries) {
+    const sub = buildOp(expr, subOp, subVal, params, dialect);
+    if (sub && sub.trim().length > 0) clauses.push(`(${sub})`);
+  }
+  if (clauses.length === 0) return "";
+  if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
+  return `${SQL_TEMPLATES.NOT} (${clauses.join(separator)})`;
+}
+function buildScalarOperator(expr, op, val, params, mode, fieldType, dialect) {
+  if (val === void 0) return "";
+  if (val === null) {
+    return handleNullValue(expr, op);
+  }
+  if (op === Ops.NOT && isPlainObject(val)) {
+    return handleNotOperator(expr, val, params, mode, fieldType, dialect);
+  }
+  if (op === Ops.NOT) {
+    const placeholder = params.addAuto(val);
+    return `${expr} <> ${placeholder}`;
+  }
+  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && isNotNullish(dialect)) {
+    const placeholder = params.addAuto(val);
+    return caseInsensitiveEquals(expr, placeholder);
+  }
+  const STRING_LIKE_OPS = /* @__PURE__ */ new Set([
+    Ops.CONTAINS,
+    Ops.STARTS_WITH,
+    Ops.ENDS_WITH
+  ]);
+  if (STRING_LIKE_OPS.has(op)) {
+    if (!isNotNullish(dialect)) {
+      throw createError(`Like operators require a SQL dialect`, {
+        operator: op
+      });
+    }
+    return handleLikeOperator(expr, op, val, params, mode, dialect);
+  }
+  if (op === Ops.IN || op === Ops.NOT_IN) {
+    if (!isNotNullish(dialect)) {
+      throw createError(`IN operators require a SQL dialect`, { operator: op });
+    }
+    return handleInOperator(expr, op, val, params, dialect);
+  }
+  return handleComparisonOperator(expr, op, val, params);
+}
+function handleNullValue(expr, op) {
+  if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+  if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  throw createError(`Operator '${op}' doesn't support null`, { operator: op });
+}
+function normalizeMode(v) {
+  if (v === Modes.INSENSITIVE) return Modes.INSENSITIVE;
+  if (v === Modes.DEFAULT) return Modes.DEFAULT;
+  return void 0;
+}
+function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
+  const innerMode = normalizeMode(val.mode);
+  const effectiveMode = innerMode != null ? innerMode : outerMode;
+  return buildNotComposite(
+    expr,
+    val,
+    params,
+    dialect,
+    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, effectiveMode, fieldType, d),
+    ` ${SQL_TEMPLATES.AND} `
+  );
+}
+function buildDynamicLikePattern(op, placeholder, dialect) {
+  if (dialect === "postgres") {
+    switch (op) {
+      case Ops.CONTAINS:
+        return `('%' || ${placeholder} || '%')`;
+      case Ops.STARTS_WITH:
+        return `(${placeholder} || '%')`;
+      case Ops.ENDS_WITH:
+        return `('%' || ${placeholder})`;
+      default:
+        return placeholder;
+    }
+  }
+  switch (op) {
+    case Ops.CONTAINS:
+      return `('%' || ${placeholder} || '%')`;
+    case Ops.STARTS_WITH:
+      return `(${placeholder} || '%')`;
+    case Ops.ENDS_WITH:
+      return `('%' || ${placeholder})`;
+    default:
+      return placeholder;
+  }
+}
+function handleLikeOperator(expr, op, val, params, mode, dialect) {
+  if (val === void 0) return "";
+  if (schemaParser.isDynamicParameter(val)) {
+    const placeholder2 = params.addAuto(val);
+    const patternExpr = buildDynamicLikePattern(op, placeholder2, dialect);
+    if (mode === Modes.INSENSITIVE) {
+      return caseInsensitiveLike(expr, patternExpr, dialect);
+    }
+    return `${expr} ${SQL_TEMPLATES.LIKE} ${patternExpr}`;
+  }
+  const placeholder = params.add(Wildcards[op](String(val)));
+  if (mode === Modes.INSENSITIVE) {
+    return caseInsensitiveLike(expr, placeholder, dialect);
+  }
+  return `${expr} ${SQL_TEMPLATES.LIKE} ${placeholder}`;
+}
+function handleInOperator(expr, op, val, params, dialect) {
+  if (val === void 0) return "";
+  if (schemaParser.isDynamicParameter(val)) {
+    const placeholder2 = params.addAuto(val);
+    return op === Ops.IN ? inArray(expr, placeholder2, dialect) : notInArray(expr, placeholder2, dialect);
+  }
+  if (!Array.isArray(val)) {
+    throw createError(`IN operators require array value`, {
+      operator: op,
+      value: val
+    });
+  }
+  if (val.length === 0) {
+    return op === Ops.IN ? "0=1" : "1=1";
+  }
+  const paramValue = prepareArrayParam(val, dialect);
+  const placeholder = params.add(paramValue);
+  return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
+}
+function handleComparisonOperator(expr, op, val, params) {
+  if (val === void 0) return "";
+  const COMPARISON_OPS2 = {
+    [Ops.EQUALS]: "=",
+    [Ops.GT]: ">",
+    [Ops.GTE]: ">=",
+    [Ops.LT]: "<",
+    [Ops.LTE]: "<="
+  };
+  const sqlOp = COMPARISON_OPS2[op];
+  if (!sqlOp) {
+    throw createError(`Unsupported scalar operator: ${op}`, { operator: op });
+  }
+  const placeholder = params.addAuto(val);
+  return `${expr} ${sqlOp} ${placeholder}`;
+}
+function buildArrayParam(val, params, dialect) {
+  if (schemaParser.isDynamicParameter(val)) {
+    return params.addAuto(val);
+  }
+  if (!Array.isArray(val)) {
+    throw createError(`Array operation requires array value`, { value: val });
+  }
+  const paramValue = prepareArrayParam(val, dialect);
+  return params.add(paramValue);
+}
+function buildArrayOperator(expr, op, val, params, fieldType, dialect) {
+  if (val === void 0) return "";
+  if (val === null) {
+    if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+    if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  }
+  const cast = getArrayType(fieldType, dialect);
+  if (op === Ops.EQUALS) {
+    return handleArrayEquals(expr, val, params, cast, dialect);
+  }
+  if (op === Ops.NOT) {
+    return handleArrayNot(expr, val, params, cast, dialect);
+  }
+  switch (op) {
+    case Ops.HAS:
+      return handleArrayHas(expr, val, params, cast, dialect);
+    case Ops.HAS_SOME:
+      return handleArrayHasSome(expr, val, params, cast, dialect);
+    case Ops.HAS_EVERY:
+      return handleArrayHasEvery(expr, val, params, cast, dialect);
+    case Ops.IS_EMPTY:
+      return handleArrayIsEmpty(expr, val, dialect);
+    default:
+      throw createError(`Unknown array operator: ${op}`, { operator: op });
+  }
+}
+function handleArrayEquals(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  if (isEmptyArray(val)) {
+    return arrayIsEmpty(expr, dialect);
+  }
+  const placeholder = buildArrayParam(val, params, dialect);
+  return arrayEquals(expr, placeholder, cast, dialect);
+}
+function handleArrayNot(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  let target = val;
+  if (isPlainObject(val)) {
+    const entries = Object.entries(val).filter(([, v]) => v !== void 0);
+    if (entries.length === 1 && entries[0][0] === Ops.EQUALS) {
+      target = entries[0][1];
+    } else {
+      throw createError(`Array NOT only supports { equals: ... } shape`, {
+        operator: Ops.NOT,
+        value: val
+      });
+    }
+  }
+  if (target === null) {
+    return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  }
+  if (isEmptyArray(target)) {
+    return arrayIsNotEmpty(expr, dialect);
+  }
+  const placeholder = buildArrayParam(target, params, dialect);
+  return `${SQL_TEMPLATES.NOT} (${arrayEquals(expr, placeholder, cast, dialect)})`;
+}
+function handleArrayHas(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  if (val === null) {
+    throw createError(`has requires scalar value`, {
+      operator: Ops.HAS,
+      value: val
+    });
+  }
+  if (!schemaParser.isDynamicParameter(val) && Array.isArray(val)) {
+    throw createError(`has requires scalar value (single element), not array`, {
+      operator: Ops.HAS,
+      value: val
+    });
+  }
+  if (isPlainObject(val)) {
+    throw createError(`has requires scalar value`, {
+      operator: Ops.HAS,
+      value: val
+    });
+  }
+  const placeholder = params.addAuto(val);
+  return arrayContains(expr, placeholder, cast, dialect);
+}
+function handleArrayHasSome(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  if (schemaParser.isDynamicParameter(val)) {
+    const placeholder2 = params.addAuto(val);
+    return arrayOverlaps(expr, placeholder2, cast, dialect);
+  }
+  if (!Array.isArray(val)) {
+    throw createError(`hasSome requires array value`, {
+      operator: Ops.HAS_SOME,
+      value: val
+    });
+  }
+  if (val.length > LIMITS.MAX_ARRAY_SIZE) {
+    throw createError(
+      `Array too large (${val.length} elements, max ${LIMITS.MAX_ARRAY_SIZE})`,
+      { operator: Ops.HAS_SOME, value: `[${val.length} items]` }
+    );
+  }
+  if (val.length === 0) return "0=1";
+  const paramValue = prepareArrayParam(val, dialect);
+  const placeholder = params.add(paramValue);
+  return arrayOverlaps(expr, placeholder, cast, dialect);
+}
+function handleArrayHasEvery(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  const placeholder = buildArrayParam(val, params, dialect);
+  return arrayContainsAll(expr, placeholder, cast, dialect);
+}
+function handleArrayIsEmpty(expr, val, dialect) {
+  if (typeof val !== "boolean") {
+    throw createError(`isEmpty requires boolean value`, {
+      operator: Ops.IS_EMPTY,
+      value: val
+    });
+  }
+  return val === true ? arrayIsEmpty(expr, dialect) : arrayIsNotEmpty(expr, dialect);
+}
+
+// src/builder/where/operators-json.ts
+var SAFE_JSON_PATH_SEGMENT = /^[a-zA-Z_]\w*$/;
+function validateJsonPathSegments(segments) {
+  for (const segment of segments) {
+    if (typeof segment !== "string") {
+      throw createError("JSON path segments must be strings", {
+        operator: Ops.PATH,
+        value: segment
+      });
+    }
+    if (!SAFE_JSON_PATH_SEGMENT.test(segment)) {
+      throw createError(
+        `Invalid JSON path segment: '${segment}'. Must be alphanumeric with underscores, starting with letter or underscore.`,
+        { operator: Ops.PATH, value: segment }
+      );
+    }
+  }
+}
+function buildJsonOperator(expr, op, val, params, dialect) {
+  if (val === void 0) return "";
+  if (op === Ops.PATH && isPlainObject(val) && "path" in val) {
+    return handleJsonPath(expr, val, params, dialect);
+  }
+  const jsonWildcards = {
+    [Ops.STRING_CONTAINS]: (v) => `%${v}%`,
+    [Ops.STRING_STARTS_WITH]: (v) => `${v}%`,
+    [Ops.STRING_ENDS_WITH]: (v) => `%${v}`
+  };
+  if (op in jsonWildcards) {
+    return handleJsonWildcard(expr, op, val, params, jsonWildcards, dialect);
+  }
+  throw createError(`Unsupported JSON operator: ${op}`, { operator: op });
+}
+function handleJsonPath(expr, val, params, dialect) {
+  const v = val;
+  if (!Array.isArray(v.path)) {
+    throw createError("JSON path must be an array", { operator: Ops.PATH });
+  }
+  if (v.path.length === 0) {
+    throw createError("JSON path cannot be empty", { operator: Ops.PATH });
+  }
+  validateJsonPathSegments(v.path);
+  const pathExpr = dialect === "sqlite" ? params.add(`$.${v.path.join(".")}`) : params.add(v.path);
+  const rawOps = [
+    ["=", v.equals],
+    [">", v.gt],
+    [">=", v.gte],
+    ["<", v.lt],
+    ["<=", v.lte]
+  ];
+  const ops = rawOps.filter(
+    ([, value]) => value !== void 0
+  );
+  if (ops.length === 0) {
+    throw createError("JSON path query missing comparison operator", {
+      operator: Ops.PATH
+    });
+  }
+  const parts = [];
+  for (const [sqlOp, value] of ops) {
+    if (value === null) {
+      const base2 = jsonExtractText(expr, pathExpr, dialect);
+      parts.push(`${base2} ${SQL_TEMPLATES.IS_NULL}`);
+      continue;
+    }
+    const valPh = params.add(value);
+    const base = typeof value === "number" ? jsonExtractNumeric(expr, pathExpr, dialect) : jsonExtractText(expr, pathExpr, dialect);
+    parts.push(`${base} ${sqlOp} ${valPh}`);
+  }
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function handleJsonWildcard(expr, op, val, params, wildcards, dialect) {
+  if (!isNotNullish(val)) {
+    throw createError(`JSON string operator requires non-null value`, {
+      operator: op,
+      value: val
+    });
+  }
+  if (isPlainObject(val) || Array.isArray(val)) {
+    throw createError(`JSON string operator requires scalar value`, {
+      operator: op,
+      value: val
+    });
+  }
+  const strVal = String(val);
+  if (strVal.length > LIMITS.MAX_STRING_LENGTH) {
+    throw createError(
+      `String too long (${strVal.length} chars, max ${LIMITS.MAX_STRING_LENGTH})`,
+      { operator: op }
+    );
+  }
+  const placeholder = params.add(wildcards[op](strVal));
+  const jsonText = jsonToText(expr, dialect);
+  return caseInsensitiveLike(jsonText, placeholder, dialect);
+}
+
+// src/builder/where/relations.ts
+var NO_JOINS = Object.freeze([]);
+function isListRelation(fieldType) {
+  return typeof fieldType === "string" && fieldType.endsWith("[]");
+}
+function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join2, wantNull) {
+  const isLocal = field.isForeignKeyLocal === true;
+  const fkFields = normalizeKeyList(field.foreignKey);
+  if (isLocal) {
+    if (fkFields.length === 0) {
+      throw createError(`Relation '${field.name}' is missing foreignKey`, {
+        field: field.name
+      });
+    }
+    const parts = fkFields.map((fk) => {
+      const safe = fk.replace(/"/g, '""');
+      const expr = `${parentAlias}."${safe}"`;
+      return wantNull ? `${expr} ${SQL_TEMPLATES.IS_NULL}` : `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+    });
+    if (parts.length === 1) return parts[0];
+    return wantNull ? `(${parts.join(" OR ")})` : `(${parts.join(" AND ")})`;
+  }
+  const existsSql = `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias} ${SQL_TEMPLATES.WHERE} ${join2})`;
+  return wantNull ? `${SQL_TEMPLATES.NOT} ${existsSql}` : existsSql;
+}
+function buildToOneExistsMatch(relTable, relAlias, join2, sub) {
+  const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
+  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${sub.clause})`;
+}
+function buildToOneNotExistsMatch(relTable, relAlias, join2, sub) {
+  const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
+  return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${sub.clause})`;
+}
+function buildListRelationFilters(args) {
+  const {
+    fieldName,
+    value,
+    ctx,
+    whereBuilder,
+    relModel,
+    relTable,
+    relAlias,
+    join: join2
+  } = args;
+  const noneValue = value[RelationFilters.NONE];
+  if (noneValue !== void 0 && noneValue !== null) {
+    const sub = whereBuilder.build(noneValue, __spreadProps(__spreadValues({}, ctx), {
+      alias: relAlias,
+      model: relModel,
+      path: [...ctx.path, fieldName, RelationFilters.NONE],
+      isSubquery: true,
+      depth: ctx.depth + 1
+    }));
+    const isEmptyFilter = isPlainObject(noneValue) && Object.keys(noneValue).length === 0;
+    const canOptimize = !ctx.isSubquery && isEmptyFilter && sub.clause === DEFAULT_WHERE_CLAUSE && sub.joins.length === 0;
+    if (canOptimize) {
+      const checkField = relModel.fields.find(
+        (f) => !f.isRelation && f.isRequired && f.name !== "id"
+      ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
+      if (checkField) {
+        const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join2}`;
+        const whereClause = `${relAlias}.${quote(checkField.name)} IS NULL`;
+        return Object.freeze({
+          clause: whereClause,
+          joins: [leftJoinSql]
+        });
+      }
+    }
+  }
+  const filters = [
+    {
+      key: RelationFilters.SOME,
+      wrap: (c, j) => `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${c})`
+    },
+    {
+      key: RelationFilters.EVERY,
+      wrap: (c, j) => `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${SQL_TEMPLATES.NOT} (${c}))`
+    },
+    {
+      key: RelationFilters.NONE,
+      wrap: (c, j) => {
+        const condition = c === DEFAULT_WHERE_CLAUSE ? "" : ` ${SQL_TEMPLATES.AND} ${c}`;
+        return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join2}${condition})`;
+      }
+    }
+  ];
+  const clauses = [];
+  for (const { key, wrap } of filters) {
+    const raw = value[key];
+    if (raw === void 0 || raw === null) continue;
+    const sub = whereBuilder.build(raw, __spreadProps(__spreadValues({}, ctx), {
+      alias: relAlias,
+      model: relModel,
+      path: [...ctx.path, fieldName, key],
+      isSubquery: true,
+      depth: ctx.depth + 1
+    }));
+    const j = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
+    clauses.push(wrap(sub.clause, j));
+  }
+  if (clauses.length === 0) {
+    throw createError(
+      `List relation '${fieldName}' requires one of { some, every, none }`,
+      { field: fieldName, path: ctx.path, modelName: ctx.model.name }
+    );
+  }
+  return Object.freeze({
+    clause: clauses.join(SQL_SEPARATORS.CONDITION_AND),
+    joins: NO_JOINS
+  });
+}
+function buildToOneRelationFilters(args) {
+  const {
+    fieldName,
+    value,
+    ctx,
+    whereBuilder,
+    field,
+    relModel,
+    relTable,
+    relAlias,
+    join: join2
+  } = args;
+  const hasSomeEveryNone = isNotNullish(value[RelationFilters.SOME]) || isNotNullish(value[RelationFilters.EVERY]) || isNotNullish(value[RelationFilters.NONE]);
+  if (hasSomeEveryNone) {
+    throw createError(
+      `To-one relation '${fieldName}' does not support { some, every, none }; use { is, isNot }`,
+      { field: fieldName, path: ctx.path, modelName: ctx.model.name }
+    );
+  }
+  const hasIs = Object.prototype.hasOwnProperty.call(value, "is");
+  const hasIsNot = Object.prototype.hasOwnProperty.call(value, "isNot");
+  let filterKey;
+  let filterVal;
+  if (hasIs) {
+    filterKey = "is";
+    filterVal = value.is;
+  } else if (hasIsNot) {
+    filterKey = "isNot";
+    filterVal = value.isNot;
+  } else {
+    filterKey = "is";
+    filterVal = value;
+  }
+  if (filterVal === void 0) {
+    return Object.freeze({
+      clause: DEFAULT_WHERE_CLAUSE,
+      joins: NO_JOINS
+    });
+  }
+  if (filterVal === null) {
+    const wantNull = filterKey === "is";
+    const clause2 = buildToOneNullCheck(
+      field,
+      ctx.alias,
+      relTable,
+      relAlias,
+      join2,
+      wantNull
+    );
+    return Object.freeze({
+      clause: clause2,
+      joins: NO_JOINS
+    });
+  }
+  if (!isPlainObject(filterVal)) {
+    throw createError(
+      `Relation '${fieldName}' filter must be an object or null`,
+      {
+        field: fieldName,
+        path: ctx.path,
+        modelName: ctx.model.name,
+        value: filterVal
+      }
+    );
+  }
+  const sub = whereBuilder.build(filterVal, __spreadProps(__spreadValues({}, ctx), {
+    alias: relAlias,
+    model: relModel,
+    path: [...ctx.path, fieldName, filterKey],
+    isSubquery: true,
+    depth: ctx.depth + 1
+  }));
+  const clause = filterKey === "is" ? buildToOneExistsMatch(relTable, relAlias, join2, sub) : buildToOneNotExistsMatch(relTable, relAlias, join2, sub);
+  return Object.freeze({
+    clause,
+    joins: NO_JOINS
+  });
+}
+function ensureRelationFilterObject(fieldName, value, ctx) {
+  if (!isPlainObject(value)) {
+    throw createError(`Relation filter '${fieldName}' must be an object`, {
+      path: [...ctx.path, fieldName],
+      field: fieldName,
+      modelName: ctx.model.name,
+      value
+    });
+  }
+}
+function buildRelation(fieldName, value, ctx, whereBuilder) {
+  const field = ctx.model.fields.find((f) => f.name === fieldName);
+  if (!isValidRelationField(field)) {
+    throw createError(`Invalid relation '${fieldName}'`, {
+      field: fieldName,
+      path: ctx.path,
+      modelName: ctx.model.name
+    });
+  }
+  const relModel = ctx.schemaModels.find((m) => m.name === field.relatedModel);
+  if (!isNotNullish(relModel)) {
+    throw createError(
+      `Related model '${field.relatedModel}' not found in schema. Available models: ${ctx.schemaModels.map((m) => m.name).join(", ")}`,
+      {
+        field: fieldName,
+        path: ctx.path,
+        modelName: ctx.model.name
+      }
+    );
+  }
+  const relTable = buildTableReference(
+    SQL_TEMPLATES.PUBLIC_SCHEMA,
+    relModel.tableName,
+    ctx.dialect
+  );
+  const relAlias = ctx.aliasGen.next(fieldName);
+  const join2 = joinCondition(field, ctx.alias, relAlias);
+  const args = {
+    fieldName,
+    value,
+    ctx,
+    whereBuilder,
+    field,
+    relModel,
+    relTable,
+    relAlias,
+    join: join2
+  };
+  if (isListRelation(field.type)) return buildListRelationFilters(args);
+  return buildToOneRelationFilters(args);
+}
+function buildTopLevelRelation(fieldName, value, ctx, whereBuilder) {
+  ensureRelationFilterObject(fieldName, value, ctx);
+  return buildRelation(fieldName, value, ctx, whereBuilder);
+}
+function buildNestedRelation(fieldName, value, ctx, whereBuilder) {
+  return buildTopLevelRelation(fieldName, value, ctx, whereBuilder);
+}
+
+// src/builder/shared/validators/field-validators.ts
+function assertFieldExists(name, model, path) {
+  const field = model.fields.find((f) => f.name === name);
+  if (!isNotNullish(field)) {
+    throw createError(`Field '${name}' does not exist on '${model.name}'`, {
+      field: name,
+      path,
+      modelName: model.name,
+      availableFields: model.fields.map((f) => f.name)
+    });
+  }
+  return field;
+}
+function assertValidOperator(fieldName, op, fieldType, path, modelName) {
+  if (!isNotNullish(fieldType)) return;
+  const ARRAY_OPS = /* @__PURE__ */ new Set([
+    Ops.HAS,
+    Ops.HAS_SOME,
+    Ops.HAS_EVERY,
+    Ops.IS_EMPTY
+  ]);
+  const JSON_OPS = /* @__PURE__ */ new Set([
+    Ops.PATH,
+    Ops.STRING_CONTAINS,
+    Ops.STRING_STARTS_WITH,
+    Ops.STRING_ENDS_WITH
+  ]);
+  const isArrayOp = ARRAY_OPS.has(op);
+  const isFieldArray = isArrayType(fieldType);
+  const arrayOpMismatch = isArrayOp && !isFieldArray;
+  if (arrayOpMismatch) {
+    throw createError(`'${op}' requires array field, got '${fieldType}'`, {
+      operator: op,
+      field: fieldName,
+      path,
+      modelName
+    });
+  }
+  const isJsonOp = JSON_OPS.has(op);
+  const isFieldJson = isJsonType(fieldType);
+  const jsonOpMismatch = isJsonOp && !isFieldJson;
+  if (jsonOpMismatch) {
+    throw createError(`'${op}' requires JSON field, got '${fieldType}'`, {
+      operator: op,
+      field: fieldName,
+      path,
+      modelName
+    });
+  }
+}
+
+// src/builder/where/builder.ts
+var WhereBuilder = class {
+  build(where, ctx) {
+    if (!isPlainObject(where)) {
+      throw createError("where must be an object", {
+        path: ctx.path,
+        modelName: ctx.model.name
+      });
+    }
+    return buildWhereInternal(where, ctx, this);
+  }
+};
+var MAX_QUERY_DEPTH = 50;
+var EMPTY_JOINS = Object.freeze([]);
+var whereBuilderInstance = new WhereBuilder();
+function freezeResult(clause, joins = EMPTY_JOINS) {
+  return Object.freeze({ clause, joins });
+}
+function dedupePreserveOrder(items) {
+  if (items.length <= 1) return Object.freeze([...items]);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of items) {
+    if (!seen.has(s)) {
+      seen.add(s);
+      out.push(s);
+    }
+  }
+  return Object.freeze(out);
+}
+function appendResult(result, clauses, allJoins) {
+  if (isValidWhereClause(result.clause)) clauses.push(result.clause);
+  if (isNonEmptyArray(result.joins)) allJoins.push(...result.joins);
+}
+function asLogicalOperator(key) {
+  if (key === LogicalOps.AND) return "AND";
+  if (key === LogicalOps.OR) return "OR";
+  if (key === LogicalOps.NOT) return "NOT";
+  return null;
+}
+function nextContext(ctx) {
+  return __spreadProps(__spreadValues({}, ctx), { depth: ctx.depth + 1 });
+}
+function buildRelationFilter(fieldName, value, ctx, builder) {
+  const ctx2 = nextContext(ctx);
+  if (ctx.isSubquery) {
+    return buildNestedRelation(fieldName, value, ctx2, builder);
+  }
+  return buildTopLevelRelation(fieldName, value, ctx2, builder);
+}
+function buildWhereEntry(key, value, ctx, builder) {
+  const op = asLogicalOperator(key);
+  if (op) return buildLogical(op, value, ctx, builder);
+  if (isRelationField(key, ctx.model)) {
+    if (!isPlainObject(value)) {
+      throw createError(`Relation filter '${key}' must be an object`, {
+        path: [...ctx.path, key],
+        field: key,
+        modelName: ctx.model.name,
+        value
+      });
+    }
+    return buildRelationFilter(key, value, ctx, builder);
+  }
+  return buildScalarField(key, value, ctx);
+}
+function buildWhereInternal(where, ctx, builder) {
+  if (ctx.depth > MAX_QUERY_DEPTH) {
+    throw createError(
+      `Query nesting too deep (max ${MAX_QUERY_DEPTH} levels). This usually indicates a circular reference.`,
+      { path: ctx.path, modelName: ctx.model.name }
+    );
+  }
+  if (isEmptyWhere(where)) {
+    return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
+  }
+  const allJoins = [];
+  const clauses = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    const result = buildWhereEntry(key, value, ctx, builder);
+    appendResult(result, clauses, allJoins);
+  }
+  const finalClause = clauses.length > 0 ? clauses.join(SQL_SEPARATORS.CONDITION_AND) : DEFAULT_WHERE_CLAUSE;
+  return freezeResult(finalClause, dedupePreserveOrder(allJoins));
+}
+function normalizeLogicalValue(operator, value, ctx) {
+  if (Array.isArray(value)) {
+    const out = [];
+    for (let i = 0; i < value.length; i++) {
+      const v = value[i];
+      if (v === void 0) continue;
+      if (!isPlainObject(v)) {
+        throw createError(`${operator} entries must be objects`, {
+          path: [...ctx.path, operator, String(i)],
+          modelName: ctx.model.name,
+          value: v
+        });
+      }
+      out.push(v);
+    }
+    return out;
+  }
+  if (isPlainObject(value)) {
+    return [value];
+  }
+  throw createError(`${operator} must be an object or array of objects`, {
+    path: [...ctx.path, operator],
+    modelName: ctx.model.name,
+    value
+  });
+}
+function collectLogicalParts(operator, conditions, ctx, builder) {
+  const allJoins = [];
+  const clauses = [];
+  for (let i = 0; i < conditions.length; i++) {
+    const result = builder.build(conditions[i], __spreadProps(__spreadValues({}, ctx), {
+      path: [...ctx.path, operator, String(i)],
+      depth: ctx.depth + 1
+    }));
+    if (isNonEmptyArray(result.joins)) allJoins.push(...result.joins);
+    if (result.clause && result.clause !== DEFAULT_WHERE_CLAUSE) {
+      clauses.push(`(${result.clause})`);
+    }
+  }
+  return {
+    joins: dedupePreserveOrder(allJoins),
+    clauses: Object.freeze(clauses)
+  };
+}
+function buildLogicalClause(operator, clauses) {
+  if (clauses.length === 0) return DEFAULT_WHERE_CLAUSE;
+  if (operator === "NOT") {
+    if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
+    return `${SQL_TEMPLATES.NOT} (${clauses.join(SQL_SEPARATORS.CONDITION_AND)})`;
+  }
+  return clauses.join(` ${operator} `);
+}
+function buildLogical(operator, value, ctx, builder) {
+  const conditions = normalizeLogicalValue(operator, value, ctx);
+  if (conditions.length === 0) {
+    const clause2 = operator === "OR" ? "0=1" : DEFAULT_WHERE_CLAUSE;
+    return freezeResult(clause2, EMPTY_JOINS);
+  }
+  const { joins, clauses } = collectLogicalParts(
+    operator,
+    conditions,
+    ctx,
+    builder
+  );
+  const clause = buildLogicalClause(operator, clauses);
+  return freezeResult(clause, joins);
+}
+function buildScalarField(fieldName, value, ctx) {
+  const field = assertFieldExists(fieldName, ctx.model, ctx.path);
+  const expr = col(ctx.alias, fieldName);
+  if (value === null) {
+    return freezeResult(`${expr} ${SQL_TEMPLATES.IS_NULL}`, EMPTY_JOINS);
+  }
+  if (isPlainObject(value)) {
+    const mode = value.mode;
+    const ops = Object.entries(value).filter(
+      ([k, v]) => k !== "mode" && v !== void 0
+    );
+    if (ops.length === 0) {
+      return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
+    }
+    const parts = [];
+    for (const [op, val] of ops) {
+      assertValidOperator(fieldName, op, field.type, ctx.path, ctx.model.name);
+      const clause3 = buildOperator(expr, op, val, ctx, mode, field.type);
+      if (isValidWhereClause(clause3)) parts.push(clause3);
+    }
+    const clause2 = parts.length > 0 ? parts.join(SQL_SEPARATORS.CONDITION_AND) : DEFAULT_WHERE_CLAUSE;
+    return freezeResult(clause2, EMPTY_JOINS);
+  }
+  const clause = buildOperator(
+    expr,
+    Ops.EQUALS,
+    value,
+    ctx,
+    void 0,
+    field.type
+  );
+  return freezeResult(clause || DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
+}
+function buildOperator(expr, op, val, ctx, mode, fieldType) {
+  if (fieldType && isArrayType(fieldType)) {
+    return buildArrayOperator(expr, op, val, ctx.params, fieldType, ctx.dialect);
+  }
+  if (fieldType && isJsonType(fieldType)) {
+    return buildJsonOperator(expr, op, val, ctx.params, ctx.dialect);
+  }
+  return buildScalarOperator(
+    expr,
+    op,
+    val,
+    ctx.params,
+    mode,
+    fieldType,
+    ctx.dialect
+  );
+}
+
+// src/builder/shared/alias-generator.ts
+function toSafeSqlIdentifier(input) {
+  const raw = String(input);
+  const cleaned = raw.replace(/\W/g, "_");
+  const startsOk = /^[a-zA-Z_]/.test(cleaned);
+  const base = startsOk ? cleaned : `_${cleaned}`;
+  const fallback = base.length > 0 ? base : "_t";
+  const lowered = fallback.toLowerCase();
+  return SQL_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
+}
+function createAliasGenerator(maxAliases = 1e4) {
+  let counter = 0;
+  const usedAliases = /* @__PURE__ */ new Set();
+  return {
+    next(baseName) {
+      if (usedAliases.size >= maxAliases) {
+        throw new Error(
+          `Alias generator exceeded maximum of ${maxAliases} aliases. This indicates a query complexity issue or potential infinite loop.`
+        );
+      }
+      const base = toSafeSqlIdentifier(baseName);
+      const suffix = `_${counter}`;
+      const maxLen = 63;
+      const baseMax = Math.max(1, maxLen - suffix.length);
+      const trimmedBase = base.length > baseMax ? base.slice(0, baseMax) : base;
+      const alias = `${trimmedBase}${suffix}`;
+      counter += 1;
+      if (usedAliases.has(alias)) {
+        throw new Error(
+          `CRITICAL: Duplicate alias '${alias}' at counter=${counter}. This indicates a bug in alias generation logic.`
+        );
+      }
+      usedAliases.add(alias);
+      return alias;
+    }
+  };
+}
+var MAX_PARAM_INDEX = Number.MAX_SAFE_INTEGER - 1e3;
+function assertSameLength(params, mappings) {
+  if (params.length !== mappings.length) {
+    throw new Error(
+      `CRITICAL: State corruption - params=${params.length}, mappings=${mappings.length}`
+    );
+  }
+}
+function assertValidNextIndex(index) {
+  if (!Number.isInteger(index) || index < 1) {
+    throw new Error(`CRITICAL: Index must be integer >= 1, got ${index}`);
+  }
+}
+function assertNextIndexMatches(mappingsLength, nextIndex) {
+  const expected = mappingsLength + 1;
+  if (nextIndex !== expected) {
+    throw new Error(
+      `CRITICAL: Next index mismatch - expected ${expected}, got ${nextIndex}`
+    );
+  }
+}
+function assertSequentialIndex(actual, expected) {
+  if (actual !== expected) {
+    throw new Error(
+      `CRITICAL: Indices must be sequential from 1..N. Expected ${expected}, got ${actual}`
+    );
+  }
+}
+function assertExactlyOneOfDynamicOrValue(m) {
+  const hasDynamic = typeof m.dynamicName === "string";
+  const hasStatic = m.value !== void 0;
+  if (hasDynamic === hasStatic) {
+    throw new Error(
+      `CRITICAL: ParamMap ${m.index} must have exactly one of dynamicName or value`
+    );
+  }
+}
+function normalizeDynamicNameOrThrow(dynamicName, index) {
+  const dn = dynamicName.trim();
+  if (dn.length === 0) {
+    throw new Error(`CRITICAL: dynamicName cannot be empty (index=${index})`);
+  }
+  return dn;
+}
+function assertUniqueDynamicName(dn, seen) {
+  if (seen.has(dn)) {
+    throw new Error(`CRITICAL: Duplicate dynamic param name in mappings: ${dn}`);
+  }
+  seen.add(dn);
+}
+function validateMappingEntry(m, expectedIndex, seenDynamic) {
+  assertSequentialIndex(m.index, expectedIndex);
+  assertExactlyOneOfDynamicOrValue(m);
+  if (typeof m.dynamicName === "string") {
+    const dn = normalizeDynamicNameOrThrow(m.dynamicName, m.index);
+    assertUniqueDynamicName(dn, seenDynamic);
+  }
+}
+function validateMappings(mappings) {
+  const seenDynamic = /* @__PURE__ */ new Set();
+  for (let i = 0; i < mappings.length; i++) {
+    validateMappingEntry(mappings[i], i + 1, seenDynamic);
+  }
+}
+function validateState(params, mappings, index) {
+  assertSameLength(params, mappings);
+  assertValidNextIndex(index);
+  if (mappings.length === 0) return;
+  validateMappings(mappings);
+  assertNextIndexMatches(mappings.length, index);
+}
+function normalizeValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return value;
+}
+function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
+  let index = startIndex;
+  const params = [...initialParams];
+  const mappings = [...initialMappings];
+  const dynamicNameToIndex = /* @__PURE__ */ new Map();
+  for (const m of initialMappings) {
+    if (typeof m.dynamicName === "string") {
+      dynamicNameToIndex.set(m.dynamicName.trim(), m.index);
+    }
+  }
+  function assertCanAdd() {
+    if (index > MAX_PARAM_INDEX) {
+      throw new Error(
+        `CRITICAL: Cannot add param - would overflow MAX_SAFE_INTEGER. Current index: ${index}`
+      );
+    }
+  }
+  function normalizeDynamicName(dynamicName) {
+    const dn = dynamicName.trim();
+    if (dn.length === 0) {
+      throw new Error("CRITICAL: dynamicName cannot be empty");
+    }
+    return dn;
+  }
+  function format(position) {
+    return `$${position}`;
+  }
+  function addDynamic(dynamicName) {
+    const dn = normalizeDynamicName(dynamicName);
+    const existing = dynamicNameToIndex.get(dn);
+    if (existing !== void 0) {
+      return format(existing);
+    }
+    const position = index;
+    dynamicNameToIndex.set(dn, position);
+    params.push(void 0);
+    mappings.push({ index: position, dynamicName: dn });
+    index++;
+    return format(position);
+  }
+  function addStatic(value) {
+    const position = index;
+    const normalizedValue = normalizeValue(value);
+    params.push(normalizedValue);
+    mappings.push({ index: position, value: normalizedValue });
+    index++;
+    return format(position);
+  }
+  function add(value, dynamicName) {
+    assertCanAdd();
+    return dynamicName === void 0 ? addStatic(value) : addDynamic(dynamicName);
+  }
+  function addAuto(value) {
+    if (schemaParser.isDynamicParameter(value)) {
+      const dynamicName = schemaParser.extractDynamicName(value);
+      return add(void 0, dynamicName);
+    }
+    return add(value);
+  }
+  function snapshot() {
+    return Object.freeze({
+      index,
+      params: Object.freeze([...params]),
+      mappings: Object.freeze([...mappings])
+    });
+  }
+  return {
+    add,
+    addAuto,
+    snapshot,
+    get index() {
+      return index;
+    }
+  };
+}
+function createParamStore(startIndex = 1) {
+  if (!Number.isInteger(startIndex) || startIndex < 1) {
+    throw new Error(`Start index must be integer >= 1, got ${startIndex}`);
+  }
+  if (startIndex > MAX_PARAM_INDEX) {
+    throw new Error(
+      `Start index too high (${startIndex}), risk of overflow at MAX_SAFE_INTEGER`
+    );
+  }
+  return createStoreInternal(startIndex);
+}
+function createParamStoreFrom(existingParams, existingMappings, nextIndex) {
+  validateState([...existingParams], [...existingMappings], nextIndex);
+  return createStoreInternal(
+    nextIndex,
+    [...existingParams],
+    [...existingMappings]
+  );
+}
+
+// src/builder/shared/state.ts
+function toPublicResult(clause, joins, params) {
+  const snapshot = params.snapshot();
+  return Object.freeze({
+    clause: clause || DEFAULT_WHERE_CLAUSE,
+    joins: Object.freeze([...joins]),
+    params: snapshot.params,
+    paramMappings: snapshot.mappings,
+    nextParamIndex: snapshot.index
+  });
+}
+
+// src/builder/where.ts
+function buildWhereClause(where, options) {
+  var _a, _b, _c, _d, _e;
+  const dialect = options.dialect || getGlobalDialect();
+  const params = (_a = options.params) != null ? _a : createParamStore();
+  const ctx = {
+    alias: options.alias,
+    model: options.model,
+    schemaModels: (_b = options.schemaModels) != null ? _b : [],
+    path: (_c = options.path) != null ? _c : [],
+    isSubquery: (_d = options.isSubquery) != null ? _d : false,
+    aliasGen: (_e = options.aliasGen) != null ? _e : createAliasGenerator(),
+    dialect,
+    params,
+    depth: 0
+  };
+  const result = whereBuilderInstance.build(where, ctx);
+  const publicResult = toPublicResult(result.clause, result.joins, params);
+  if (!options.isSubquery) {
+    const nums = [...publicResult.clause.matchAll(/\$(\d+)/g)].map(
+      (m) => parseInt(m[1], 10)
+    );
+    if (nums.length > 0) {
+      const min = Math.min(...nums);
+      if (min === 1) {
+        validateParamConsistency(publicResult.clause, publicResult.params);
+      } else {
+        validateParamConsistencyFragment(
+          publicResult.clause,
+          publicResult.params
+        );
+      }
+    }
+  }
+  return publicResult;
+}
+function normalizeIntLike(name, v, opts = {}) {
+  var _a, _b;
+  if (!isNotNullish(v)) return void 0;
+  if (schemaParser.isDynamicParameter(v)) return v;
+  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
+    throw new Error(`${name} must be an integer`);
+  }
+  const min = (_a = opts.min) != null ? _a : 0;
+  const allowZero = (_b = opts.allowZero) != null ? _b : true;
+  if (!allowZero && v === 0) {
+    throw new Error(`${name} must be > 0`);
+  }
+  if (v < min) {
+    throw new Error(`${name} must be >= ${min}`);
+  }
+  if (typeof opts.max === "number" && v > opts.max) {
+    throw new Error(`${name} must be <= ${opts.max}`);
+  }
+  return v;
+}
+function scopeName(scope, dynamicName) {
+  const s = String(scope).trim();
+  const dn = String(dynamicName).trim();
+  if (s.length === 0) return dn;
+  return `${s}:${dn}`;
+}
+function addAutoScoped(params, value, scope) {
+  if (schemaParser.isDynamicParameter(value)) {
+    const dn = schemaParser.extractDynamicName(value);
+    return params.add(void 0, scopeName(scope, dn));
+  }
+  return params.add(value);
+}
+
+// src/builder/shared/order-by-utils.ts
+var flipNulls = (v) => {
+  const s = String(v).toLowerCase();
+  if (s === "first") return "last";
+  if (s === "last") return "first";
+  return v;
+};
+var flipSortString = (v) => {
+  if (typeof v !== "string") return v;
+  const s = v.toLowerCase();
+  if (s === "asc") return "desc";
+  if (s === "desc") return "asc";
+  return v;
+};
+var getNextSort = (sortRaw) => {
+  if (typeof sortRaw !== "string") return sortRaw;
+  const s = sortRaw.toLowerCase();
+  if (s === "asc") return "desc";
+  if (s === "desc") return "asc";
+  return sortRaw;
+};
+var flipObjectSort = (obj) => {
+  const sortRaw = obj.sort;
+  const out = __spreadProps(__spreadValues({}, obj), { sort: getNextSort(sortRaw) });
+  const nullsRaw = obj.nulls;
+  if (typeof nullsRaw === "string") {
+    out.nulls = flipNulls(nullsRaw);
+  }
+  return out;
+};
+var flipValue = (v) => {
+  if (typeof v === "string") return flipSortString(v);
+  if (isPlainObject(v)) return flipObjectSort(v);
+  return v;
+};
+var assertSingleFieldObject = (item) => {
+  if (!isPlainObject(item)) {
+    throw new Error("orderBy array entries must be objects");
+  }
+  const entries = Object.entries(item);
+  if (entries.length !== 1) {
+    throw new Error("orderBy array entries must have exactly one field");
+  }
+  return entries[0];
+};
+var flipOrderByArray = (orderBy) => {
+  return orderBy.map((item) => {
+    const [k, v] = assertSingleFieldObject(item);
+    return { [k]: flipValue(v) };
+  });
+};
+var flipOrderByObject = (orderBy) => {
+  const out = {};
+  for (const [k, v] of Object.entries(orderBy)) {
+    out[k] = flipValue(v);
+  }
+  return out;
+};
+function reverseOrderByInput(orderBy) {
+  if (!isNotNullish(orderBy)) return orderBy;
+  if (Array.isArray(orderBy)) {
+    return flipOrderByArray(orderBy);
+  }
+  if (isPlainObject(orderBy)) {
+    return flipOrderByObject(orderBy);
+  }
+  throw new Error("orderBy must be an object or array of objects");
+}
+var normalizePairs = (pairs, parseValue) => {
+  return pairs.map(([field, rawValue]) => {
+    const parsed = parseValue(rawValue, field);
+    return {
+      [field]: parsed.nulls !== void 0 ? { sort: parsed.direction, nulls: parsed.nulls } : parsed.direction
+    };
+  });
+};
+function normalizeOrderByInput(orderBy, parseValue) {
+  if (!isNotNullish(orderBy)) return [];
+  if (Array.isArray(orderBy)) {
+    const pairs = orderBy.map(assertSingleFieldObject);
+    return normalizePairs(pairs, parseValue);
+  }
+  if (isPlainObject(orderBy)) {
+    return normalizePairs(Object.entries(orderBy), parseValue);
+  }
+  throw new Error("orderBy must be an object or array of objects");
+}
+
+// src/builder/pagination.ts
+var MAX_LIMIT_OFFSET = 2147483647;
+function parseDirectionRaw(raw, errorLabel) {
+  const s = String(raw).toLowerCase();
+  if (s === "asc" || s === "desc") return s;
+  throw new Error(`Invalid ${errorLabel}: ${raw}`);
+}
+function parseNullsRaw(raw, errorLabel) {
+  if (!isNotNullish(raw)) return void 0;
+  const s = String(raw).toLowerCase();
+  if (s === "first" || s === "last") return s;
+  throw new Error(`Invalid ${errorLabel}: ${raw}`);
+}
+function requireOrderByObject(v, errorPrefix) {
+  if (!isPlainObject(v) || !("sort" in v)) {
+    throw new Error(`${errorPrefix} must be 'asc' | 'desc' or { sort, nulls? }`);
+  }
+  return v;
+}
+function assertAllowedOrderByKeys(obj, fieldName) {
+  const allowed = /* @__PURE__ */ new Set(["sort", "nulls"]);
+  for (const k of Object.keys(obj)) {
+    if (!allowed.has(k)) {
+      throw new Error(
+        fieldName ? `Unsupported orderBy key '${k}' for field '${fieldName}'` : `Unsupported orderBy key '${k}'`
+      );
+    }
+  }
+}
+function parseOrderByValue(v, fieldName) {
+  const errorPrefix = fieldName ? `orderBy for '${fieldName}'` : "orderBy value";
+  if (typeof v === "string") {
+    return { direction: parseDirectionRaw(v, `${errorPrefix} direction`) };
+  }
+  const obj = requireOrderByObject(v, errorPrefix);
+  const direction = parseDirectionRaw(obj.sort, `${errorPrefix}.sort`);
+  const nulls = parseNullsRaw(obj.nulls, `${errorPrefix}.nulls`);
+  assertAllowedOrderByKeys(obj, fieldName);
+  return { direction, nulls };
+}
+function normalizeFiniteInteger(name, v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
+    throw new Error(`${name} must be an integer`);
+  }
+  return v;
+}
+function normalizeNonNegativeInt(name, v) {
+  if (schemaParser.isDynamicParameter(v)) return v;
+  const n = normalizeFiniteInteger(name, v);
+  if (n < 0) {
+    throw new Error(`${name} must be >= 0`);
+  }
+  if (n > MAX_LIMIT_OFFSET) {
+    throw new Error(`${name} must be <= ${MAX_LIMIT_OFFSET}`);
+  }
+  return n;
+}
+function hasNonNullishProp(v, key) {
+  return isPlainObject(v) && key in v && isNotNullish(v[key]);
+}
+function normalizeIntegerOrDynamic(name, v) {
+  if (schemaParser.isDynamicParameter(v)) return v;
+  return normalizeFiniteInteger(name, v);
+}
+function readSkipTake(relArgs) {
+  const hasSkip = hasNonNullishProp(relArgs, "skip");
+  const hasTake = hasNonNullishProp(relArgs, "take");
+  if (!hasSkip && !hasTake) {
+    return {
+      hasSkip: false,
+      hasTake: false,
+      skipVal: void 0,
+      takeVal: void 0
+    };
+  }
+  const obj = relArgs;
+  const skipVal = hasSkip ? normalizeNonNegativeInt("skip", obj.skip) : void 0;
+  const takeVal = hasTake ? normalizeIntegerOrDynamic("take", obj.take) : void 0;
+  return { hasSkip, hasTake, skipVal, takeVal };
+}
+function buildOrderByFragment(entries, alias, dialect) {
+  if (entries.length === 0) return "";
+  const out = [];
+  for (const e of entries) {
+    const dir = e.direction.toUpperCase();
+    const c = col(alias, e.field);
+    if (dialect === "postgres") {
+      const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
+      out.push(`${c} ${dir}${nulls}`);
+      continue;
+    }
+    if (isNotNullish(e.nulls)) {
+      const isNullExpr = `(${c} IS NULL)`;
+      const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
+      out.push(`${isNullExpr} ${nullRankDir}`);
+      out.push(`${c} ${dir}`);
+      continue;
+    }
+    out.push(`${c} ${dir}`);
+  }
+  return out.join(SQL_SEPARATORS.ORDER_BY);
+}
+function defaultNullsFor(dialect, direction) {
+  if (dialect === "postgres") {
+    return direction === "asc" ? "last" : "first";
+  }
+  return direction === "asc" ? "first" : "last";
+}
+function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
+  const existing = /* @__PURE__ */ new Map();
+  for (const e of orderEntries) existing.set(e.field, e);
+  const out = [...orderEntries];
+  for (const [field] of cursorEntries) {
+    if (!existing.has(field)) {
+      out.push({ field, direction: "asc" });
+      existing.set(field, out[out.length - 1]);
+    }
+  }
+  return out;
+}
+function buildCursorFilterParts(cursor, cursorAlias, params) {
+  const entries = Object.entries(cursor);
+  if (entries.length === 0) {
+    throw new Error("cursor must have at least one field");
+  }
+  const placeholdersByField = /* @__PURE__ */ new Map();
+  const parts = [];
+  for (const [field, value] of entries) {
+    const c = `${cursorAlias}.${quote(field)}`;
+    if (value === null) {
+      parts.push(`${c} IS NULL`);
+      continue;
+    }
+    const ph = addAutoScoped(params, value, `cursor.filter.${field}`);
+    placeholdersByField.set(field, ph);
+    parts.push(`${c} = ${ph}`);
+  }
+  return {
+    whereSql: parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`,
+    placeholdersByField
+  };
+}
+function cursorValueExpr(tableName, cursorAlias, cursorWhereSql, field) {
+  return `(SELECT ${cursorAlias}.${quote(field)} ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
+}
+function buildCursorRowExistsExpr(tableName, cursorAlias, cursorWhereSql) {
+  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
+}
+function buildCursorEqualityExpr(columnExpr, valueExpr) {
+  return `((${valueExpr} IS NULL AND ${columnExpr} IS NULL) OR (${valueExpr} IS NOT NULL AND ${columnExpr} = ${valueExpr}))`;
+}
+function buildCursorInequalityExpr(columnExpr, direction, nulls, valueExpr) {
+  const op = direction === "asc" ? ">" : "<";
+  if (nulls === "first") {
+    return `(CASE WHEN ${valueExpr} IS NULL THEN (${columnExpr} IS NOT NULL) ELSE (${columnExpr} ${op} ${valueExpr}) END)`;
+  }
+  return `(CASE WHEN ${valueExpr} IS NULL THEN 0=1 ELSE ((${columnExpr} ${op} ${valueExpr}) OR (${columnExpr} IS NULL)) END)`;
+}
+function buildOuterCursorMatch(cursor, outerAlias, placeholdersByField, params) {
+  const parts = [];
+  for (const [field, value] of Object.entries(cursor)) {
+    const c = col(outerAlias, field);
+    if (value === null) {
+      parts.push(`${c} IS NULL`);
+      continue;
+    }
+    const existing = placeholdersByField.get(field);
+    if (typeof existing === "string" && existing.length > 0) {
+      parts.push(`${c} = ${existing}`);
+      continue;
+    }
+    const ph = addAutoScoped(params, value, `cursor.outerMatch.${field}`);
+    parts.push(`${c} = ${ph}`);
+  }
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function buildOrderEntries(orderBy) {
+  const normalized = normalizeOrderByInput(orderBy, parseOrderByValue);
+  const entries = [];
+  for (const item of normalized) {
+    for (const [field, value] of Object.entries(item)) {
+      if (typeof value === "string") {
+        entries.push({ field, direction: value });
+      } else {
+        entries.push({
+          field,
+          direction: value.sort,
+          nulls: value.nulls
+        });
+      }
+    }
+  }
+  return entries;
+}
+function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect) {
+  var _a;
+  const d = dialect != null ? dialect : getGlobalDialect();
+  const cursorEntries = Object.entries(cursor);
+  if (cursorEntries.length === 0) {
+    throw new Error("cursor must have at least one field");
+  }
+  const cursorAlias = "__tp_cursor_src";
+  const { whereSql: cursorWhereSql, placeholdersByField } = buildCursorFilterParts(cursor, cursorAlias, params);
+  let orderEntries = buildOrderEntries(orderBy);
+  if (orderEntries.length === 0) {
+    orderEntries = cursorEntries.map(([field]) => ({
+      field,
+      direction: "asc"
+    }));
+  } else {
+    orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
+  }
+  const existsExpr = buildCursorRowExistsExpr(
+    tableName,
+    cursorAlias,
+    cursorWhereSql
+  );
+  const outerCursorMatch = buildOuterCursorMatch(
+    cursor,
+    alias,
+    placeholdersByField,
+    params
+  );
+  const orClauses = [];
+  for (let level = 0; level < orderEntries.length; level++) {
+    const andParts = [];
+    for (let i = 0; i < level; i++) {
+      const e2 = orderEntries[i];
+      const c2 = col(alias, e2.field);
+      const v2 = cursorValueExpr(tableName, cursorAlias, cursorWhereSql, e2.field);
+      andParts.push(buildCursorEqualityExpr(c2, v2));
+    }
+    const e = orderEntries[level];
+    const c = col(alias, e.field);
+    const v = cursorValueExpr(tableName, cursorAlias, cursorWhereSql, e.field);
+    const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
+    andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, v));
+    orClauses.push(`(${andParts.join(SQL_SEPARATORS.CONDITION_AND)})`);
+  }
+  const exclusive = orClauses.join(SQL_SEPARATORS.CONDITION_OR);
+  return `(${existsExpr} ${SQL_SEPARATORS.CONDITION_AND} ((${exclusive})${SQL_SEPARATORS.CONDITION_OR}(${outerCursorMatch})))`;
+}
+function buildOrderBy(orderBy, alias, dialect) {
+  const entries = buildOrderEntries(orderBy);
+  if (entries.length === 0) return "";
+  const d = dialect != null ? dialect : getGlobalDialect();
+  return buildOrderByFragment(entries, alias, d);
+}
+function buildOrderByClause(args, alias, dialect) {
+  if (!isNotNullish(args.orderBy)) return "";
+  const result = buildOrderBy(args.orderBy, alias, dialect);
+  if (!isNonEmptyString(result)) {
+    throw new Error(
+      "buildOrderByClause: orderBy specified but produced empty result"
+    );
+  }
+  return result;
+}
+function normalizeTakeLike(v) {
+  const n = normalizeIntLike("take", v, {
+    min: Number.MIN_SAFE_INTEGER,
+    max: MAX_LIMIT_OFFSET,
+    allowZero: true
+  });
+  if (typeof n === "number") {
+    if (n === 0) return 0;
+  }
+  return n;
+}
+function normalizeSkipLike(v) {
+  return normalizeIntLike("skip", v, {
+    min: 0,
+    max: MAX_LIMIT_OFFSET,
+    allowZero: true
+  });
+}
+function getPaginationParams(method, args) {
+  if (method === "findMany") {
+    return {
+      take: normalizeTakeLike(args.take),
+      skip: normalizeSkipLike(args.skip),
+      cursor: args.cursor
+    };
+  }
+  if (method === "findFirst") {
+    const skip = normalizeSkipLike(args.skip);
+    return { take: 1, skip: skip != null ? skip : 0 };
+  }
+  if (method === "findUnique") {
+    return { take: 1, skip: 0 };
+  }
+  return {};
+}
+
+// src/builder/select/fields.ts
+function toSelectEntries(select) {
+  const out = [];
+  for (const [k, v] of Object.entries(select)) {
+    if (v !== false && v !== void 0) out.push([k, v]);
+  }
+  return out;
+}
+function validateSelectKeys(entries, scalarSet, relationSet) {
+  const unknown = [];
+  for (const [k] of entries) {
+    if (k === "_count") continue;
+    if (!scalarSet.has(k) && !relationSet.has(k)) unknown.push(k);
+  }
+  if (unknown.length > 0) {
+    throw new Error(`Select contains unknown fields: ${unknown.join(", ")}`);
+  }
+}
+function analyzeSelectEntries(entries, scalarSet, relationSet) {
+  const scalarSelected = [];
+  let hasRelationSelection = false;
+  let hasCount = false;
+  for (const [k, v] of entries) {
+    if (k === "_count") {
+      hasCount = true;
+      continue;
+    }
+    if (relationSet.has(k)) hasRelationSelection = true;
+    if (scalarSet.has(k) && v === true) scalarSelected.push(k);
+  }
+  return { scalarSelected, hasRelationSelection, hasCount };
+}
+function buildDefaultScalarFields(model, alias) {
+  const excludedPrefixes = [
+    SCHEMA_PREFIXES.INTERNAL,
+    SCHEMA_PREFIXES.COMMENT
+  ];
+  const out = [];
+  for (const f of model.fields) {
+    if (f.isRelation) continue;
+    const excluded = excludedPrefixes.some((p) => f.name.startsWith(p));
+    if (!excluded) out.push(col(alias, f.name));
+  }
+  if (!isNonEmptyArray(out)) {
+    throw new Error(`Model ${model.name} has no selectable fields`);
+  }
+  return out;
+}
+function buildSelectFields(args, model, alias) {
+  const scalarSet = getScalarFieldSet(model);
+  const relationSet = getRelationFieldSet(model);
+  if (!isNotNullish(args.select)) {
+    return buildDefaultScalarFields(model, alias).join(
+      SQL_SEPARATORS.FIELD_LIST
+    );
+  }
+  const entries = toSelectEntries(args.select);
+  validateSelectKeys(entries, scalarSet, relationSet);
+  const { scalarSelected, hasRelationSelection, hasCount } = analyzeSelectEntries(entries, scalarSet, relationSet);
+  const fields = scalarSelected.map((field) => col(alias, field));
+  if (!isNonEmptyArray(fields)) {
+    if (hasRelationSelection) return "";
+    if (!hasCount) {
+      throw new Error("Select must have at least one scalar field set to true");
+    }
+  }
+  return fields.join(SQL_SEPARATORS.FIELD_LIST);
+}
+function buildAllScalarParts(model, alias) {
+  const scalarFields = model.fields.filter((f) => !f.isRelation);
+  if (!isNonEmptyArray(scalarFields)) {
+    throw new Error(`Model ${model.name} has no scalar fields`);
+  }
+  const parts = [];
+  for (const field of scalarFields) {
+    parts.push(`${sqlStringLiteral(field.name)}, ${col(alias, field.name)}`);
+  }
+  return parts;
+}
+function validateRelationSelectKeys(entries, scalarNames, relationNames) {
+  const unknown = [];
+  for (const [k] of entries) {
+    if (!scalarNames.has(k) && !relationNames.has(k)) unknown.push(k);
+  }
+  if (unknown.length > 0) {
+    throw new Error(`Select contains unknown fields: ${unknown.join(", ")}`);
+  }
+}
+function buildSelectedScalarParts(entries, scalarNames, alias) {
+  const parts = [];
+  for (const [key, value] of entries) {
+    if (!scalarNames.has(key)) continue;
+    if (value === true) {
+      parts.push(`${sqlStringLiteral(key)}, ${col(alias, key)}`);
+    }
+  }
+  return parts;
+}
+function buildRelationSelect(relArgs, relModel, relAlias) {
+  if (relArgs === true) {
+    return buildAllScalarParts(relModel, relAlias).join(
+      SQL_SEPARATORS.FIELD_LIST
+    );
+  }
+  if (isPlainObject(relArgs) && hasProperty(relArgs, "select")) {
+    const sel = relArgs.select;
+    if (!isPlainObject(sel)) {
+      throw new Error(
+        `Relation select must be an object for model ${relModel.name}`
+      );
+    }
+    const scalarNames = new Set(
+      relModel.fields.filter((f) => !f.isRelation).map((f) => f.name)
+    );
+    const relationNames = new Set(
+      relModel.fields.filter((f) => f.isRelation).map((f) => f.name)
+    );
+    const entries = toSelectEntries(sel);
+    validateRelationSelectKeys(entries, scalarNames, relationNames);
+    return buildSelectedScalarParts(entries, scalarNames, relAlias).join(
+      SQL_SEPARATORS.FIELD_LIST
+    );
+  }
+  return buildAllScalarParts(relModel, relAlias).join(SQL_SEPARATORS.FIELD_LIST);
+}
+
+// src/builder/select/includes.ts
+function getRelationTableReference(relModel, dialect) {
+  return buildTableReference(
+    SQL_TEMPLATES.PUBLIC_SCHEMA,
+    relModel.tableName,
+    dialect
+  );
+}
+function resolveRelationOrThrow(model, schemas, relName) {
+  const field = model.fields.find((f) => f.name === relName);
+  if (!isNotNullish(field)) {
+    throw new Error(
+      `Unknown relation '${relName}' on model ${model.name}. Available relation fields: ${model.fields.filter((f) => f.isRelation).map((f) => f.name).join(", ")}`
+    );
+  }
+  if (!isValidRelationField(field)) {
+    throw new Error(
+      `Invalid relation metadata for '${relName}' on model ${model.name}. This usually indicates a schema parsing error (missing foreignKey/references).`
+    );
+  }
+  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  if (!isNotNullish(relModel)) {
+    throw new Error(
+      `Relation '${relName}' on model ${model.name} references missing model '${field.relatedModel}'.`
+    );
+  }
+  return { field, relModel };
+}
+function relationEntriesFromArgs(args, model) {
+  const relationSet = getRelationFieldSet(model);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushFrom = (src) => {
+    if (!isPlainObject(src)) return;
+    for (const [k, v] of Object.entries(src)) {
+      if (v === false) continue;
+      if (!relationSet.has(k)) continue;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      out.push([k, v]);
+    }
+  };
+  pushFrom(args.include);
+  pushFrom(args.select);
+  return out;
+}
+function assertScalarField(model, fieldName) {
+  const f = model.fields.find((x) => x.name === fieldName);
+  if (!f) {
+    throw new Error(
+      `orderBy references unknown field '${fieldName}' on model ${model.name}`
+    );
+  }
+  if (f.isRelation) {
+    throw new Error(
+      `orderBy does not support relation field '${fieldName}' on model ${model.name}`
+    );
+  }
+}
+function validateOrderByDirection(fieldName, v) {
+  const s = String(v).toLowerCase();
+  if (s !== "asc" && s !== "desc") {
+    throw new Error(
+      `Invalid orderBy direction for '${fieldName}': ${String(v)}`
+    );
+  }
+}
+function validateOrderByObject(fieldName, v) {
+  if (!("sort" in v)) {
+    throw new Error(
+      `orderBy for '${fieldName}' must be 'asc' | 'desc' or { sort, nulls? }`
+    );
+  }
+  validateOrderByDirection(fieldName, v.sort);
+  if ("nulls" in v && isNotNullish(v.nulls)) {
+    const n = String(v.nulls).toLowerCase();
+    if (n !== "first" && n !== "last") {
+      throw new Error(
+        `Invalid orderBy.nulls for '${fieldName}': ${String(v.nulls)}`
+      );
+    }
+  }
+  const allowed = /* @__PURE__ */ new Set(["sort", "nulls"]);
+  for (const k of Object.keys(v)) {
+    if (!allowed.has(k)) {
+      throw new Error(`Unsupported orderBy key '${k}' for field '${fieldName}'`);
+    }
+  }
+}
+function normalizeOrderByFieldName(name) {
+  const fieldName = String(name).trim();
+  if (fieldName.length === 0) {
+    throw new Error("orderBy field name cannot be empty");
+  }
+  return fieldName;
+}
+function requirePlainObjectForOrderByEntry(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) {
+    throw new Error("orderBy array entries must be objects");
+  }
+  return v;
+}
+function parseSingleFieldOrderByObject(obj) {
+  const entries = Object.entries(obj);
+  if (entries.length !== 1) {
+    throw new Error("orderBy array entries must have exactly one field");
+  }
+  const fieldName = normalizeOrderByFieldName(entries[0][0]);
+  return [fieldName, entries[0][1]];
+}
+function parseOrderByArray(orderBy) {
+  return orderBy.map(
+    (item) => parseSingleFieldOrderByObject(requirePlainObjectForOrderByEntry(item))
+  );
+}
+function parseOrderByObject(orderBy) {
+  const out = [];
+  for (const [k, v] of Object.entries(orderBy)) {
+    out.push([normalizeOrderByFieldName(k), v]);
+  }
+  return out;
+}
+function getOrderByEntries(orderBy) {
+  if (!isNotNullish(orderBy)) return [];
+  if (Array.isArray(orderBy)) {
+    return parseOrderByArray(orderBy);
+  }
+  if (typeof orderBy === "object" && orderBy !== null) {
+    return parseOrderByObject(orderBy);
+  }
+  throw new Error("orderBy must be an object or array of objects");
+}
+function validateOrderByForModel(model, orderBy) {
+  const entries = getOrderByEntries(orderBy);
+  for (const [fieldName, v] of entries) {
+    assertScalarField(model, fieldName);
+    if (typeof v === "string") {
+      validateOrderByDirection(fieldName, v);
+      continue;
+    }
+    if (isPlainObject(v)) {
+      validateOrderByObject(fieldName, v);
+      continue;
+    }
+    throw new Error(
+      `orderBy for '${fieldName}' must be 'asc' | 'desc' or { sort, nulls? }`
+    );
+  }
+}
+function appendLimitOffset(sql, dialect, params, takeVal, skipVal, scope) {
+  const hasTake = isNotNullish(takeVal);
+  const hasSkip = isNotNullish(skipVal);
+  if (dialect === "sqlite" && !hasTake && hasSkip) {
+    const skipPh = addAutoScoped(params, skipVal, `${scope}.skip`);
+    return `${sql} ${SQL_TEMPLATES.LIMIT} -1 ${SQL_TEMPLATES.OFFSET} ${skipPh}`;
+  }
+  if (hasTake) {
+    const takePh = addAutoScoped(params, takeVal, `${scope}.take`);
+    sql = `${sql} ${SQL_TEMPLATES.LIMIT} ${takePh}`;
+  }
+  if (hasSkip) {
+    const skipPh = addAutoScoped(params, skipVal, `${scope}.skip`);
+    sql = `${sql} ${SQL_TEMPLATES.OFFSET} ${skipPh}`;
+  }
+  return sql;
+}
+function readWhereInput(relArgs) {
+  if (!isPlainObject(relArgs)) return {};
+  if (!hasProperty(relArgs, "where")) return {};
+  const w = relArgs.where;
+  return isPlainObject(w) ? w : {};
+}
+function readOrderByInput(relArgs) {
+  if (!isPlainObject(relArgs)) return { hasOrderBy: false, orderBy: void 0 };
+  if (!("orderBy" in relArgs)) return { hasOrderBy: false, orderBy: void 0 };
+  return { hasOrderBy: true, orderBy: relArgs.orderBy };
+}
+function extractRelationPaginationConfig(relArgs) {
+  const { hasOrderBy, orderBy: rawOrderByInput } = readOrderByInput(relArgs);
+  const {
+    hasSkip,
+    hasTake,
+    skipVal,
+    takeVal: rawTakeVal
+  } = readSkipTake(relArgs);
+  return {
+    hasOrderBy,
+    orderBy: rawOrderByInput,
+    hasSkip,
+    hasTake,
+    skipVal,
+    takeVal: rawTakeVal
+  };
+}
+function maybeReverseNegativeTake(takeVal, hasOrderBy, orderByInput) {
+  if (typeof takeVal !== "number") return { takeVal, orderByInput };
+  if (takeVal >= 0) return { takeVal, orderByInput };
+  if (!hasOrderBy) {
+    throw new Error("Negative take requires orderBy for deterministic results");
+  }
+  return {
+    takeVal: Math.abs(takeVal),
+    orderByInput: reverseOrderByInput(orderByInput)
+  };
+}
+function hasIdTiebreaker(orderByInput) {
+  const entries = Array.isArray(orderByInput) ? orderByInput : [orderByInput];
+  return entries.some(
+    (entry) => isPlainObject(entry) ? Object.prototype.hasOwnProperty.call(entry, "id") : false
+  );
+}
+function modelHasScalarId(relModel) {
+  const idField = relModel.fields.find((f) => f.name === "id");
+  return Boolean(idField && !idField.isRelation);
+}
+function addIdTiebreaker(orderByInput) {
+  if (Array.isArray(orderByInput)) return [...orderByInput, { id: "asc" }];
+  return [orderByInput, { id: "asc" }];
+}
+function ensureDeterministicOrderBy(relModel, hasOrderBy, orderByInput, hasPagination) {
+  if (!hasPagination) {
+    if (hasOrderBy && isNotNullish(orderByInput)) {
+      validateOrderByForModel(relModel, orderByInput);
+    }
+    return orderByInput;
+  }
+  if (!hasOrderBy) {
+    return modelHasScalarId(relModel) ? { id: "asc" } : orderByInput;
+  }
+  if (isNotNullish(orderByInput)) {
+    validateOrderByForModel(relModel, orderByInput);
+  }
+  if (!modelHasScalarId(relModel)) return orderByInput;
+  if (hasIdTiebreaker(orderByInput)) return orderByInput;
+  return addIdTiebreaker(orderByInput);
+}
+function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
+  let relSelect = buildRelationSelect(relArgs, relModel, relAlias);
+  const nestedIncludes = isPlainObject(relArgs) ? buildIncludeSqlInternal(
+    relArgs,
+    relModel,
+    ctx.schemas,
+    relAlias,
+    ctx.aliasGen,
+    ctx.params,
+    ctx.dialect
+  ) : [];
+  if (isNonEmptyArray(nestedIncludes)) {
+    const emptyJson = ctx.dialect === "postgres" ? `'[]'::json` : `json('[]')`;
+    const nestedSelects = nestedIncludes.map(
+      (inc) => inc.isOneToOne ? `${sqlStringLiteral(inc.name)}, (${inc.sql})` : `${sqlStringLiteral(inc.name)}, COALESCE((${inc.sql}), ${emptyJson})`
+    ).join(SQL_SEPARATORS.FIELD_LIST);
+    relSelect = isNotNullish(relSelect) && relSelect.trim().length > 0 ? `${relSelect}${SQL_SEPARATORS.FIELD_LIST}${nestedSelects}` : nestedSelects;
+  }
+  if (!isNotNullish(relSelect) || relSelect.trim().length === 0) {
+    throw new Error(
+      `Select must include at least one field or nested relation for model ${relModel.name}`
+    );
+  }
+  return relSelect;
+}
+function buildWhereParts(whereInput, relModel, relAlias, ctx) {
+  const whereResult = buildWhereClause(whereInput, {
+    alias: relAlias,
+    schemaModels: ctx.schemas,
+    model: relModel,
+    params: ctx.params,
+    isSubquery: true,
+    aliasGen: ctx.aliasGen,
+    dialect: ctx.dialect
+  });
+  const joins = whereResult.joins.join(" ");
+  const whereClause = isValidWhereClause(whereResult.clause) ? ` ${SQL_TEMPLATES.AND} ${whereResult.clause}` : "";
+  return { joins, whereClause };
+}
+function limitOneSql(sql, params, skipVal, scope) {
+  if (isNotNullish(skipVal)) {
+    const skipPh = addAutoScoped(params, skipVal, `${scope}.skip`);
+    return `${sql} ${SQL_TEMPLATES.LIMIT} 1 ${SQL_TEMPLATES.OFFSET} ${skipPh}`;
+  }
+  return `${sql} ${SQL_TEMPLATES.LIMIT} 1`;
+}
+function buildOrderBySql(finalOrderByInput, relAlias, dialect) {
+  return isNotNullish(finalOrderByInput) ? buildOrderBy(finalOrderByInput, relAlias, dialect) : "";
+}
+function buildBaseSql(args) {
+  return `${SQL_TEMPLATES.SELECT} ${args.selectExpr} ${SQL_TEMPLATES.FROM} ${args.relTable} ${args.relAlias} ${args.joins} ${SQL_TEMPLATES.WHERE} ${args.joinPredicate}${args.whereClause}`;
+}
+function buildOneToOneIncludeSql(args) {
+  const objExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
+  let sql = buildBaseSql({
+    selectExpr: objExpr,
+    relTable: args.relTable,
+    relAlias: args.relAlias,
+    joins: args.joins,
+    joinPredicate: args.joinPredicate,
+    whereClause: args.whereClause
+  });
+  if (args.orderBySql) {
+    sql += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
+  }
+  if (isNotNullish(args.takeVal)) {
+    return appendLimitOffset(
+      sql,
+      args.ctx.dialect,
+      args.ctx.params,
+      args.takeVal,
+      args.skipVal,
+      `include.${args.relName}`
+    );
+  }
+  return limitOneSql(
+    sql,
+    args.ctx.params,
+    args.skipVal,
+    `include.${args.relName}`
+  );
+}
+function buildListIncludeSpec(args) {
+  const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
+  const noTake = !isNotNullish(args.takeVal);
+  const noSkip = !isNotNullish(args.skipVal);
+  if (args.ctx.dialect === "postgres" && noTake && noSkip) {
+    const selectExpr2 = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+    const sql2 = buildBaseSql({
+      selectExpr: selectExpr2,
+      relTable: args.relTable,
+      relAlias: args.relAlias,
+      joins: args.joins,
+      joinPredicate: args.joinPredicate,
+      whereClause: args.whereClause
+    });
+    return Object.freeze({
+      name: args.relName,
+      sql: sql2,
+      isOneToOne: false
+    });
+  }
+  const rowAlias = args.ctx.aliasGen.next(`${args.relName}_row`);
+  let base = buildBaseSql({
+    selectExpr: `${rowExpr} ${SQL_TEMPLATES.AS} row`,
+    relTable: args.relTable,
+    relAlias: args.relAlias,
+    joins: args.joins,
+    joinPredicate: args.joinPredicate,
+    whereClause: args.whereClause
+  });
+  if (args.orderBySql) {
+    base += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
+  }
+  base = appendLimitOffset(
+    base,
+    args.ctx.dialect,
+    args.ctx.params,
+    args.takeVal,
+    args.skipVal,
+    `include.${args.relName}`
+  );
+  const selectExpr = jsonAgg("row", args.ctx.dialect);
+  const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${rowAlias}`;
+  return Object.freeze({
+    name: args.relName,
+    sql,
+    isOneToOne: false
+  });
+}
+function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
+  const relTable = getRelationTableReference(relModel, ctx.dialect);
+  const relAlias = ctx.aliasGen.next(relName);
+  const isList = typeof field.type === "string" && field.type.endsWith("[]");
+  const joinPredicate = joinCondition(field, ctx.parentAlias, relAlias);
+  const whereInput = readWhereInput(relArgs);
+  const relSelect = buildSelectWithNestedIncludes(
+    relArgs,
+    relModel,
+    relAlias,
+    ctx
+  );
+  const whereParts = buildWhereParts(whereInput, relModel, relAlias, ctx);
+  const paginationConfig = extractRelationPaginationConfig(relArgs);
+  if (!isList && typeof paginationConfig.takeVal === "number" && paginationConfig.takeVal < 0) {
+    throw new Error("Negative take is only supported for list relations");
+  }
+  const adjusted = maybeReverseNegativeTake(
+    paginationConfig.takeVal,
+    paginationConfig.hasOrderBy,
+    paginationConfig.orderBy
+  );
+  const hasPagination = paginationConfig.hasSkip || paginationConfig.hasTake;
+  const finalOrderByInput = ensureDeterministicOrderBy(
+    relModel,
+    paginationConfig.hasOrderBy,
+    adjusted.orderByInput,
+    hasPagination
+  );
+  const orderBySql = buildOrderBySql(finalOrderByInput, relAlias, ctx.dialect);
+  if (!isList) {
+    const sql = buildOneToOneIncludeSql({
+      relName,
+      relTable,
+      relAlias,
+      joins: whereParts.joins,
+      joinPredicate,
+      whereClause: whereParts.whereClause,
+      orderBySql,
+      relSelect,
+      takeVal: adjusted.takeVal,
+      skipVal: paginationConfig.skipVal,
+      ctx
+    });
+    return Object.freeze({
+      name: relName,
+      sql,
+      isOneToOne: true
+    });
+  }
+  return buildListIncludeSpec({
+    relName,
+    relTable,
+    relAlias,
+    joins: whereParts.joins,
+    joinPredicate,
+    whereClause: whereParts.whereClause,
+    orderBySql,
+    relSelect,
+    takeVal: adjusted.takeVal,
+    skipVal: paginationConfig.skipVal,
+    ctx
+  });
+}
+function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, params, dialect) {
+  const includes = [];
+  const entries = relationEntriesFromArgs(args, model);
+  for (const [relName, relArgs] of entries) {
+    if (relArgs === false) continue;
+    const resolved = resolveRelationOrThrow(model, schemas, relName);
+    const include = buildSingleInclude(
+      relName,
+      relArgs,
+      resolved.field,
+      resolved.relModel,
+      {
+        model,
+        schemas,
+        parentAlias,
+        aliasGen,
+        dialect,
+        params
+      }
+    );
+    includes.push(include);
+  }
+  return includes;
+}
+function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
+  const aliasGen = createAliasGenerator();
+  return buildIncludeSqlInternal(
+    args,
+    model,
+    schemas,
+    parentAlias,
+    aliasGen,
+    params,
+    dialect
+  );
+}
+function resolveCountRelationOrThrow(relName, model, schemas) {
+  const relationSet = getRelationFieldSet(model);
+  if (!relationSet.has(relName)) {
+    throw new Error(
+      `_count.${relName} references unknown relation on model ${model.name}`
+    );
+  }
+  const field = model.fields.find((f) => f.name === relName);
+  if (!field) {
+    throw new Error(
+      `_count.${relName} references unknown relation on model ${model.name}`
+    );
+  }
+  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  if (!relModel) {
+    throw new Error(
+      `Related model '${field.relatedModel}' not found for _count.${relName}`
+    );
+  }
+  return { field, relModel };
+}
+function groupByColForCount(field, countAlias) {
+  const fkFields = normalizeKeyList(field.foreignKey);
+  const refFields = normalizeKeyList(field.references);
+  return field.isForeignKeyLocal ? `${countAlias}.${quote(refFields[0] || "id")}` : `${countAlias}.${quote(fkFields[0])}`;
+}
+function leftJoinOnForCount(field, parentAlias, joinAlias) {
+  const fkFields = normalizeKeyList(field.foreignKey);
+  const refFields = normalizeKeyList(field.references);
+  return field.isForeignKeyLocal ? `${joinAlias}.__fk = ${parentAlias}.${quote(fkFields[0])}` : `${joinAlias}.__fk = ${parentAlias}.${quote(refFields[0] || "id")}`;
+}
+function subqueryForCount(dialect, relTable, countAlias, groupByCol) {
+  return dialect === "postgres" ? `(SELECT ${groupByCol} AS __fk, COUNT(*)::int AS __cnt FROM ${relTable} ${countAlias} GROUP BY ${groupByCol})` : `(SELECT ${groupByCol} AS __fk, COUNT(*) AS __cnt FROM ${relTable} ${countAlias} GROUP BY ${groupByCol})`;
+}
+function buildCountJoinAndPair(args) {
+  const relTable = getRelationTableReference(args.relModel, args.dialect);
+  const countAlias = `__tp_cnt_${args.relName}`;
+  const groupByCol = groupByColForCount(args.field, countAlias);
+  const subquery = subqueryForCount(
+    args.dialect,
+    relTable,
+    countAlias,
+    groupByCol
+  );
+  const joinAlias = `__tp_cnt_j_${args.relName}`;
+  const leftJoinOn = leftJoinOnForCount(args.field, args.parentAlias, joinAlias);
+  return {
+    joinSql: `LEFT JOIN ${subquery} ${joinAlias} ON ${leftJoinOn}`,
+    pairSql: `${sqlStringLiteral(args.relName)}, COALESCE(${joinAlias}.__cnt, 0)`
+  };
+}
+function buildRelationCountSql(countSelect, model, schemas, parentAlias, _params, dialect) {
+  const joins = [];
+  const pairs = [];
+  for (const [relName, shouldCount] of Object.entries(countSelect)) {
+    if (!shouldCount) continue;
+    const resolved = resolveCountRelationOrThrow(relName, model, schemas);
+    const built = buildCountJoinAndPair({
+      relName,
+      field: resolved.field,
+      relModel: resolved.relModel,
+      parentAlias,
+      dialect
+    });
+    joins.push(built.joinSql);
+    pairs.push(built.pairSql);
+  }
+  return {
+    joins,
+    jsonPairs: pairs.join(SQL_SEPARATORS.FIELD_LIST)
+  };
+}
+
+// src/builder/select/assembly.ts
+var SIMPLE_SELECT_RE_CACHE = /* @__PURE__ */ new Map();
+function joinNonEmpty(parts, sep) {
+  return parts.filter((s) => s.trim().length > 0).join(sep);
+}
+function buildWhereSql(conditions) {
+  if (!isNonEmptyArray(conditions)) return "";
+  return ` ${SQL_TEMPLATES.WHERE} ${conditions.join(SQL_SEPARATORS.CONDITION_AND)}`;
+}
+function buildJoinsSql(...joinGroups) {
+  const all = [];
+  for (const g of joinGroups) {
+    if (isNonEmptyArray(g)) all.push(...g);
+  }
+  return all.length > 0 ? ` ${all.join(" ")}` : "";
+}
+function buildSelectList(baseSelect, extraCols) {
+  const base = baseSelect.trim();
+  const extra = extraCols.trim();
+  if (base && extra) return `${base}${SQL_SEPARATORS.FIELD_LIST}${extra}`;
+  return base || extra;
+}
+function finalizeSql(sql, params) {
+  const snapshot = params.snapshot();
+  validateSelectQuery(sql);
+  validateParamConsistency(sql, snapshot.params);
+  return Object.freeze({
+    sql,
+    params: snapshot.params,
+    paramMappings: snapshot.mappings
+  });
+}
+function parseSimpleScalarSelect(select, alias) {
+  var _a, _b;
+  const raw = select.trim();
+  if (raw.length === 0) return [];
+  let re = SIMPLE_SELECT_RE_CACHE.get(alias);
+  if (!re) {
+    const safeAlias2 = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    re = new RegExp(`^${safeAlias2}\\.(?:"([^"]+)"|([a-z_][a-z0-9_]*))$`, "i");
+    SIMPLE_SELECT_RE_CACHE.set(alias, re);
+  }
+  const parts = raw.split(SQL_SEPARATORS.FIELD_LIST);
+  const names = [];
+  for (const part of parts) {
+    const p = part.trim();
+    const m = p.match(re);
+    if (!m) {
+      throw new Error(
+        `sqlite distinct emulation requires scalar select fields to be simple columns. Got: ${p}`
+      );
+    }
+    const name = ((_b = (_a = m[1]) != null ? _a : m[2]) != null ? _b : "").trim();
+    if (name.length === 0) {
+      throw new Error(`Failed to parse selected column name from: ${p}`);
+    }
+    names.push(name);
+  }
+  return names;
+}
+function replaceOrderByAlias(orderBy, fromAlias, outerAlias) {
+  const needle = `${fromAlias}.`;
+  const replacement = `${outerAlias}.`;
+  return orderBy.split(needle).join(replacement);
+}
+function buildDistinctColumns(distinct, fromAlias) {
+  return distinct.map((f) => col(fromAlias, f)).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function buildOutputColumns(scalarNames, includeNames, hasCount) {
+  const outputCols = [...scalarNames, ...includeNames];
+  if (hasCount) {
+    outputCols.push("_count");
+  }
+  const formatted = outputCols.map((n) => quote(n)).join(SQL_SEPARATORS.FIELD_LIST);
+  if (!isNonEmptyString(formatted)) {
+    throw new Error("distinct emulation requires at least one output column");
+  }
+  return formatted;
+}
+function buildWindowOrder(args) {
+  const { baseOrder, idField, fromAlias } = args;
+  const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase());
+  const hasIdInOrder = orderFields.some(
+    (f) => f.startsWith(`${fromAlias}.id `) || f.startsWith(`${fromAlias}."id" `)
+  );
+  if (hasIdInOrder) return baseOrder;
+  const idTiebreaker = idField ? `, ${col(fromAlias, "id")} ASC` : "";
+  return `${baseOrder}${idTiebreaker}`;
+}
+function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
+  var _a, _b;
+  const { includes, from, whereClause, whereJoins, orderBy, distinct, model } = spec;
+  if (!isNotNullish(distinct) || !isNonEmptyArray(distinct)) {
+    throw new Error("buildSqliteDistinctQuery requires distinct fields");
+  }
+  const scalarNames = parseSimpleScalarSelect(spec.select, from.alias);
+  const includeNames = includes.map((i) => i.name);
+  const hasCount = Boolean((_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count);
+  const outerSelectCols = buildOutputColumns(
+    scalarNames,
+    includeNames,
+    hasCount
+  );
+  const distinctCols = buildDistinctColumns([...distinct], from.alias);
+  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
+  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  const baseOrder = isNonEmptyString(orderBy) ? orderBy : fallbackOrder;
+  const windowOrder = buildWindowOrder({
+    baseOrder,
+    idField,
+    fromAlias: from.alias
+  });
+  const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, `"__tp_distinct"`) : replaceOrderByAlias(fallbackOrder, from.alias, `"__tp_distinct"`);
+  const joins = buildJoinsSql(whereJoins, countJoins);
+  const conditions = [];
+  if (whereClause && whereClause !== "1=1") {
+    conditions.push(whereClause);
+  }
+  const whereSql = buildWhereSql(conditions);
+  const innerSelectList = selectWithIncludes.trim();
+  const innerComma = innerSelectList.length > 0 ? SQL_SEPARATORS.FIELD_LIST : "";
+  const inner = `${SQL_TEMPLATES.SELECT} ${innerSelectList}${innerComma}ROW_NUMBER() OVER (PARTITION BY ${distinctCols} ORDER BY ${windowOrder}) ${SQL_TEMPLATES.AS} "__tp_rn" ${SQL_TEMPLATES.FROM} ${from.table} ${from.alias}${joins}${whereSql}`;
+  const outer = `${SQL_TEMPLATES.SELECT} ${outerSelectCols} ${SQL_TEMPLATES.FROM} (${inner}) ${SQL_TEMPLATES.AS} "__tp_distinct" ${SQL_TEMPLATES.WHERE} "__tp_rn" = 1` + (isNonEmptyString(outerOrder) ? ` ${SQL_TEMPLATES.ORDER_BY} ${outerOrder}` : "");
+  return outer;
+}
+function buildIncludeColumns(spec) {
+  var _a, _b;
+  const { select, includes, dialect, model, schemas, from, params } = spec;
+  const baseSelect = (select != null ? select : "").trim();
+  let countCols = "";
+  let countJoins = [];
+  const countSelect = (_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count;
+  if (countSelect) {
+    if (isPlainObject(countSelect) && "select" in countSelect) {
+      const countBuild = buildRelationCountSql(
+        countSelect.select,
+        model,
+        schemas,
+        from.alias,
+        params,
+        dialect
+      );
+      if (countBuild.jsonPairs) {
+        countCols = `${jsonBuildObject(countBuild.jsonPairs, dialect)} ${SQL_TEMPLATES.AS} ${quote("_count")}`;
+      }
+      countJoins = countBuild.joins;
+    }
+  }
+  const hasIncludes = isNonEmptyArray(includes);
+  const hasCountCols = isNonEmptyString(countCols);
+  if (!hasIncludes && !hasCountCols) {
+    return { includeCols: "", selectWithIncludes: baseSelect, countJoins: [] };
+  }
+  const emptyJson = dialect === "postgres" ? `'[]'::json` : `json('[]')`;
+  const includeCols = hasIncludes ? includes.map((inc) => {
+    const expr = inc.isOneToOne ? `(${inc.sql})` : `COALESCE((${inc.sql}), ${emptyJson})`;
+    return `${expr} ${SQL_TEMPLATES.AS} ${quote(inc.name)}`;
+  }).join(SQL_SEPARATORS.FIELD_LIST) : "";
+  const allCols = joinNonEmpty(
+    [includeCols, countCols],
+    SQL_SEPARATORS.FIELD_LIST
+  );
+  const selectWithIncludes = buildSelectList(baseSelect, allCols);
+  return { includeCols: allCols, selectWithIncludes, countJoins };
+}
+function appendPagination(sql, spec) {
+  const { method, pagination, params } = spec;
+  const isFindUniqueOrFirst = method === "findUnique" || method === "findFirst";
+  if (isFindUniqueOrFirst) {
+    const parts2 = [sql, SQL_TEMPLATES.LIMIT, "1"];
+    const hasSkip = isNotNullish(pagination.skip) && (schemaParser.isDynamicParameter(pagination.skip) || typeof pagination.skip === "number" && pagination.skip > 0) && method === "findFirst";
+    if (hasSkip) {
+      const placeholder = addAutoScoped(
+        params,
+        pagination.skip,
+        "root.pagination.skip"
+      );
+      parts2.push(SQL_TEMPLATES.OFFSET, placeholder);
+    }
+    return parts2.join(" ");
+  }
+  const parts = [sql];
+  if (isNotNullish(pagination.take)) {
+    const placeholder = addAutoScoped(
+      params,
+      pagination.take,
+      "root.pagination.take"
+    );
+    parts.push(SQL_TEMPLATES.LIMIT, placeholder);
+  }
+  if (isNotNullish(pagination.skip)) {
+    const placeholder = addAutoScoped(
+      params,
+      pagination.skip,
+      "root.pagination.skip"
+    );
+    parts.push(SQL_TEMPLATES.OFFSET, placeholder);
+  }
+  return parts.join(" ");
+}
+function hasWindowDistinct(spec) {
+  const d = spec.distinct;
+  return isNotNullish(d) && isNonEmptyArray(d);
+}
+function assertDistinctAllowed(method, enabled) {
+  if (enabled && method !== "findMany") {
+    throw new Error(
+      "distinct is only supported for findMany in this SQL builder"
+    );
+  }
+}
+function assertHasSelectFields(baseSelect, includeCols) {
+  if (!isNonEmptyString(baseSelect) && !isNonEmptyString(includeCols)) {
+    throw new Error("SELECT requires at least one selected field or include");
+  }
+}
+function withCountJoins(spec, countJoins, whereJoins) {
+  return __spreadProps(__spreadValues({}, spec), {
+    whereJoins: [...whereJoins || [], ...countJoins || []]
+  });
+}
+function buildPostgresDistinctOnClause(fromAlias, distinct) {
+  if (!isNonEmptyArray(distinct)) return null;
+  const distinctCols = buildDistinctColumns([...distinct], fromAlias);
+  return `${SQL_TEMPLATES.DISTINCT_ON} (${distinctCols})`;
+}
+function pushJoinGroups(parts, ...groups) {
+  for (const g of groups) {
+    if (isNonEmptyArray(g)) parts.push(g.join(" "));
+  }
+}
+function buildConditions(whereClause, cursorClause) {
+  const conditions = [];
+  if (whereClause && whereClause !== "1=1") conditions.push(whereClause);
+  if (isNotNullish(cursorClause) && isNonEmptyString(cursorClause))
+    conditions.push(cursorClause);
+  return conditions;
+}
+function pushWhere(parts, conditions) {
+  if (!isNonEmptyArray(conditions)) return;
+  parts.push(SQL_TEMPLATES.WHERE, conditions.join(SQL_SEPARATORS.CONDITION_AND));
+}
+function constructFinalSql(spec) {
+  const {
+    select,
+    from,
+    whereClause,
+    whereJoins,
+    orderBy,
+    distinct,
+    method,
+    cursorClause,
+    params,
+    dialect
+  } = spec;
+  const useWindowDistinct = hasWindowDistinct(spec);
+  assertDistinctAllowed(method, useWindowDistinct);
+  const { includeCols, selectWithIncludes, countJoins } = buildIncludeColumns(spec);
+  if (useWindowDistinct) {
+    const baseSelect2 = (select != null ? select : "").trim();
+    assertHasSelectFields(baseSelect2, includeCols);
+    const spec2 = withCountJoins(spec, countJoins, whereJoins);
+    let sql2 = buildSqliteDistinctQuery(spec2, selectWithIncludes).trim();
+    sql2 = appendPagination(sql2, spec);
+    return finalizeSql(sql2, params);
+  }
+  const parts = [SQL_TEMPLATES.SELECT];
+  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct) : null;
+  if (distinctOn) parts.push(distinctOn);
+  const baseSelect = (select != null ? select : "").trim();
+  const fullSelectList = buildSelectList(baseSelect, includeCols);
+  if (!isNonEmptyString(fullSelectList)) {
+    throw new Error("SELECT requires at least one selected field or include");
+  }
+  parts.push(fullSelectList);
+  parts.push(SQL_TEMPLATES.FROM, from.table, from.alias);
+  pushJoinGroups(parts, whereJoins, countJoins);
+  const conditions = buildConditions(whereClause, cursorClause);
+  pushWhere(parts, conditions);
+  if (isNonEmptyString(orderBy)) parts.push(SQL_TEMPLATES.ORDER_BY, orderBy);
+  let sql = parts.join(" ").trim();
+  sql = appendPagination(sql, spec);
+  return finalizeSql(sql, params);
+}
+
+// src/builder/select.ts
+function normalizeOrderByInput2(orderBy) {
+  return normalizeOrderByInput(orderBy, parseOrderByValue);
+}
+function normalizeDistinctFields(distinct) {
+  if (!isNonEmptyArray(distinct)) return [];
+  return distinct.filter((f) => typeof f === "string").map((f) => f.trim()).filter((f) => f.length > 0);
+}
+function mapFirstOrderByByField(existing) {
+  const m = /* @__PURE__ */ new Map();
+  for (const obj of existing) {
+    const field = Object.keys(obj)[0];
+    if (field && !m.has(field)) m.set(field, obj);
+  }
+  return m;
+}
+function buildPostgresDistinctOrderBy(distinctFields, existing) {
+  var _a;
+  const firstByField = mapFirstOrderByByField(existing);
+  const next = [];
+  for (const f of distinctFields) {
+    next.push((_a = firstByField.get(f)) != null ? _a : { [f]: "asc" });
+  }
+  const distinctSet = new Set(distinctFields);
+  for (const obj of existing) {
+    const field = Object.keys(obj)[0];
+    if (!distinctSet.has(field)) next.push(obj);
+  }
+  return next;
+}
+function applyPostgresDistinctOrderBy(args, _model) {
+  const distinctFields = normalizeDistinctFields(args.distinct);
+  if (distinctFields.length === 0) return args;
+  if (!isNotNullish(args.orderBy)) return args;
+  const existing = normalizeOrderByInput2(args.orderBy);
+  if (existing.length === 0) return args;
+  return __spreadProps(__spreadValues({}, args), {
+    orderBy: buildPostgresDistinctOrderBy(distinctFields, existing)
+  });
+}
+function assertScalarFieldOnModel(model, fieldName, ctx) {
+  const f = model.fields.find((x) => x.name === fieldName);
+  if (!f) {
+    throw new Error(
+      `${ctx} references unknown field '${fieldName}' on model ${model.name}`
+    );
+  }
+  if (f.isRelation) {
+    throw new Error(
+      `${ctx} does not support relation field '${fieldName}' on model ${model.name}`
+    );
+  }
+}
+function validateDistinct(model, distinct) {
+  if (!isNotNullish(distinct) || !isNonEmptyArray(distinct)) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of distinct) {
+    const f = String(raw).trim();
+    if (f.length === 0) continue;
+    if (seen.has(f)) {
+      throw new Error(`distinct must not contain duplicates (field: '${f}')`);
+    }
+    seen.add(f);
+    assertScalarFieldOnModel(model, f, "distinct");
+  }
+}
+function validateOrderByValue(fieldName, v) {
+  parseOrderByValue(v, fieldName);
+}
+function validateOrderBy(model, orderBy) {
+  if (!isNotNullish(orderBy)) return;
+  const items = normalizeOrderByInput2(orderBy);
+  if (items.length === 0) return;
+  for (const it of items) {
+    const entries = Object.entries(it);
+    const fieldName = String(entries[0][0]).trim();
+    if (fieldName.length === 0) {
+      throw new Error("orderBy field name cannot be empty");
+    }
+    assertScalarFieldOnModel(model, fieldName, "orderBy");
+    validateOrderByValue(fieldName, entries[0][1]);
+  }
+}
+function validateCursor(model, cursor) {
+  if (!isNotNullish(cursor)) return;
+  if (!isPlainObject(cursor)) {
+    throw new Error("cursor must be an object");
+  }
+  const entries = Object.entries(cursor);
+  if (entries.length === 0) {
+    throw new Error("cursor must have at least one field");
+  }
+  for (const [fieldName] of entries) {
+    const f = String(fieldName).trim();
+    if (f.length === 0) {
+      throw new Error("cursor field name cannot be empty");
+    }
+    assertScalarFieldOnModel(model, f, "cursor");
+  }
+}
+function resolveDialect(dialect) {
+  return dialect != null ? dialect : getGlobalDialect();
+}
+function normalizeArgsForNegativeTake(method, args) {
+  if (method !== "findMany") return args;
+  if (typeof args.take !== "number") return args;
+  if (!Number.isInteger(args.take)) return args;
+  if (args.take >= 0) return args;
+  if (!isNotNullish(args.orderBy)) {
+    throw new Error("Negative take requires orderBy for deterministic results");
+  }
+  return __spreadProps(__spreadValues({}, args), {
+    take: Math.abs(args.take),
+    orderBy: reverseOrderByInput(args.orderBy)
+  });
+}
+function normalizeArgsForDialect(dialect, args, model) {
+  if (dialect !== "postgres") return args;
+  return applyPostgresDistinctOrderBy(args);
+}
+function buildCursorClauseIfAny(input) {
+  const { cursor, orderBy, tableName, alias, params, dialect } = input;
+  if (!isNotNullish(cursor)) return void 0;
+  return buildCursorCondition(
+    cursor,
+    orderBy,
+    tableName,
+    alias,
+    params,
+    dialect
+  );
+}
+function buildSelectSpec(input) {
+  const {
+    method,
+    normalizedArgs,
+    model,
+    schemas,
+    tableName,
+    alias,
+    whereResult,
+    dialect
+  } = input;
+  const selectFields = buildSelectFields(
+    { select: normalizedArgs.select },
+    model,
+    alias
+  );
+  const orderByClause = buildOrderByClause(normalizedArgs, alias, dialect);
+  const { take, skip, cursor } = getPaginationParams(method, normalizedArgs);
+  const params = createParamStoreFrom(
+    whereResult.params,
+    whereResult.paramMappings,
+    whereResult.nextParamIndex
+  );
+  const includes = buildIncludeSql(
+    normalizedArgs,
+    model,
+    schemas,
+    alias,
+    params,
+    dialect
+  );
+  const cursorClause = buildCursorClauseIfAny({
+    cursor,
+    orderBy: normalizedArgs.orderBy,
+    tableName,
+    alias,
+    params,
+    dialect
+  });
+  return {
+    select: selectFields,
+    includes,
+    from: { table: tableName, alias },
+    whereClause: whereResult.clause,
+    whereJoins: whereResult.joins,
+    orderBy: orderByClause,
+    pagination: { take, skip },
+    distinct: normalizedArgs.distinct,
+    method,
+    cursorClause,
+    params,
+    dialect,
+    model,
+    schemas,
+    args: normalizedArgs
+  };
+}
+function buildSelectSql(input) {
+  const { method, args, model, schemas, from, whereResult, dialect } = input;
+  assertSafeAlias(from.alias);
+  assertSafeTableRef(from.tableName);
+  const dialectToUse = resolveDialect(dialect);
+  const argsForSql = normalizeArgsForNegativeTake(method, args);
+  const normalizedArgs = normalizeArgsForDialect(
+    dialectToUse,
+    argsForSql);
+  validateDistinct(model, normalizedArgs.distinct);
+  validateOrderBy(model, normalizedArgs.orderBy);
+  validateCursor(model, normalizedArgs.cursor);
+  const spec = buildSelectSpec({
+    method,
+    normalizedArgs,
+    model,
+    schemas,
+    tableName: from.tableName,
+    alias: from.alias,
+    whereResult,
+    dialect: dialectToUse
+  });
+  return constructFinalSql(spec);
+}
+var MODEL_FIELD_CACHE = /* @__PURE__ */ new WeakMap();
+var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
+var AGGREGATES = [
+  ["_sum", "SUM"],
+  ["_avg", "AVG"],
+  ["_min", "MIN"],
+  ["_max", "MAX"]
+];
+var COMPARISON_OPS = {
+  [Ops.EQUALS]: "=",
+  [Ops.NOT]: "<>",
+  [Ops.GT]: ">",
+  [Ops.GTE]: ">=",
+  [Ops.LT]: "<",
+  [Ops.LTE]: "<="
+};
+function getModelFieldMap(model) {
+  const cached = MODEL_FIELD_CACHE.get(model);
+  if (cached) return cached;
+  const m = /* @__PURE__ */ new Map();
+  for (const f of model.fields) {
+    m.set(f.name, { name: f.name, type: f.type, isRelation: !!f.isRelation });
+  }
+  MODEL_FIELD_CACHE.set(model, m);
+  return m;
+}
+function isTruthySelection(v) {
+  return v === true;
+}
+function aggExprForField(aggKey, field, alias) {
+  if (aggKey === "_count") {
+    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field)})`;
+  }
+  if (field === "_all") {
+    throw new Error(`'${aggKey}' does not support '_all'`);
+  }
+  if (aggKey === "_sum") return `SUM(${col(alias, field)})`;
+  if (aggKey === "_avg") return `AVG(${col(alias, field)})`;
+  if (aggKey === "_min") return `MIN(${col(alias, field)})`;
+  return `MAX(${col(alias, field)})`;
+}
+function buildComparisonOp(op) {
+  const sqlOp = COMPARISON_OPS[op];
+  if (!sqlOp) {
+    throw new Error(`Unsupported HAVING operator: ${op}`);
+  }
+  return sqlOp;
+}
+function addHavingParam(params, op, value) {
+  return addAutoScoped(params, value, `having.${op}`);
+}
+function normalizeLogicalValue2(operator, value) {
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const v of value) {
+      if (!isPlainObject(v)) {
+        throw new Error(`${operator} entries must be objects in HAVING`);
+      }
+      out.push(v);
+    }
+    return out;
+  }
+  if (isPlainObject(value)) {
+    return [value];
+  }
+  throw new Error(`${operator} must be an object or array of objects in HAVING`);
+}
+function assertScalarField2(model, fieldName, ctx) {
+  const m = getModelFieldMap(model);
+  const field = m.get(fieldName);
+  if (!field) {
+    throw new Error(
+      `${ctx} references unknown field '${fieldName}' on model ${model.name}. Available fields: ${model.fields.map((f) => f.name).join(", ")}`
+    );
+  }
+  if (field.isRelation) {
+    throw new Error(`${ctx} does not support relation field '${fieldName}'`);
+  }
+  return { name: field.name, type: field.type };
+}
+function assertAggregateFieldType(aggKey, fieldType, fieldName, modelName) {
+  const baseType = fieldType.replace(/\[\]|\?/g, "");
+  if ((aggKey === "_sum" || aggKey === "_avg") && !NUMERIC_TYPES.has(baseType)) {
+    throw new Error(
+      `Cannot use ${aggKey} on non-numeric field '${fieldName}' (type: ${fieldType}) on model ${modelName}`
+    );
+  }
+}
+function buildNullComparison(expr, op) {
+  if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+  if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  throw new Error(`Operator '${op}' doesn't support null in HAVING`);
+}
+function buildInComparison(expr, op, val, params, dialect) {
+  if (schemaParser.isDynamicParameter(val)) {
+    const placeholder2 = addHavingParam(params, op, val);
+    return op === Ops.IN ? inArray(expr, placeholder2, dialect) : notInArray(expr, placeholder2, dialect);
+  }
+  if (!Array.isArray(val)) {
+    throw new Error(`HAVING '${op}' requires array value`);
+  }
+  if (val.length === 0) {
+    return op === Ops.IN ? "0=1" : "1=1";
+  }
+  const paramValue = prepareArrayParam(val, dialect);
+  const placeholder = params.add(paramValue);
+  return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
+}
+function buildBinaryComparison(expr, op, val, params) {
+  const sqlOp = buildComparisonOp(op);
+  const placeholder = addHavingParam(params, op, val);
+  return `${expr} ${sqlOp} ${placeholder}`;
+}
+function buildSimpleComparison(expr, op, val, params, dialect) {
+  if (val === null) return buildNullComparison(expr, op);
+  if (op === Ops.NOT && isPlainObject(val)) {
+    return buildNotComposite(
+      expr,
+      val,
+      params,
+      dialect,
+      buildSimpleComparison,
+      SQL_SEPARATORS.CONDITION_AND
+    );
+  }
+  if (op === Ops.IN || op === Ops.NOT_IN) {
+    return buildInComparison(expr, op, val, params, dialect);
+  }
+  return buildBinaryComparison(expr, op, val, params);
+}
+function isLogicalKey(key) {
+  return key === LogicalOps.AND || key === LogicalOps.OR || key === LogicalOps.NOT;
+}
+function isAggregateKey(key) {
+  return key === "_count" || key === "_sum" || key === "_avg" || key === "_min" || key === "_max";
+}
+function negateClauses(subClauses) {
+  if (subClauses.length === 1) return `${SQL_TEMPLATES.NOT} ${subClauses[0]}`;
+  return `${SQL_TEMPLATES.NOT} (${subClauses.join(SQL_SEPARATORS.CONDITION_AND)})`;
+}
+function combineLogical(key, subClauses) {
+  if (key === LogicalOps.NOT) return negateClauses(subClauses);
+  return subClauses.join(` ${key} `);
+}
+function buildLogicalClause2(key, value, alias, params, dialect, model) {
+  const items = normalizeLogicalValue2(key, value);
+  const subClauses = [];
+  for (const it of items) {
+    const c = buildHavingNode(it, alias, params, dialect, model);
+    if (c && c !== "") subClauses.push(`(${c})`);
+  }
+  if (subClauses.length === 0) return "";
+  return combineLogical(key, subClauses);
+}
+function buildHavingEntry(key, value, alias, params, dialect, model) {
+  if (isLogicalKey(key)) {
+    const logical = buildLogicalClause2(
+      key,
+      value,
+      alias,
+      params,
+      dialect,
+      model
+    );
+    return logical ? [logical] : [];
+  }
+  if (isAggregateKey(key)) {
+    return buildHavingForAggregateFirstShape(
+      key,
+      value,
+      alias,
+      params,
+      dialect,
+      model
+    );
+  }
+  return buildHavingForFieldFirstShape(
+    key,
+    value,
+    alias,
+    params,
+    dialect,
+    model
+  );
+}
+function buildHavingNode(node, alias, params, dialect, model) {
+  const clauses = [];
+  for (const [key, value] of Object.entries(node)) {
+    const built = buildHavingEntry(key, value, alias, params, dialect, model);
+    for (const c of built) {
+      if (c && c.trim().length > 0) clauses.push(c);
+    }
+  }
+  return clauses.join(SQL_SEPARATORS.CONDITION_AND);
+}
+function assertHavingAggTarget(aggKey, field, model) {
+  if (field === "_all") {
+    if (aggKey !== "_count") {
+      throw new Error(`HAVING '${aggKey}' does not support '_all'`);
+    }
+    return;
+  }
+  const f = assertScalarField2(model, field, "HAVING");
+  assertAggregateFieldType(aggKey, f.type, f.name, model.name);
+}
+function buildHavingOpsForExpr(expr, filter, params, dialect) {
+  const out = [];
+  for (const [op, val] of Object.entries(filter)) {
+    if (op === "mode") continue;
+    const built = buildSimpleComparison(expr, op, val, params, dialect);
+    if (built && built.trim().length > 0) out.push(built);
+  }
+  return out;
+}
+function buildHavingForAggregateFirstShape(aggKey, target, alias, params, dialect, model) {
+  if (!isPlainObject(target)) return [];
+  const out = [];
+  for (const [field, filter] of Object.entries(target)) {
+    assertHavingAggTarget(aggKey, field, model);
+    if (!isPlainObject(filter) || Object.keys(filter).length === 0) continue;
+    const expr = aggExprForField(aggKey, field, alias);
+    out.push(...buildHavingOpsForExpr(expr, filter, params, dialect));
+  }
+  return out;
+}
+function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect, model) {
+  if (!isPlainObject(target)) return [];
+  const field = assertScalarField2(model, fieldName, "HAVING");
+  const out = [];
+  const obj = target;
+  const keys = ["_count", "_sum", "_avg", "_min", "_max"];
+  for (const aggKey of keys) {
+    const aggFilter = obj[aggKey];
+    if (!isPlainObject(aggFilter)) continue;
+    assertAggregateFieldType(aggKey, field.type, field.name, model.name);
+    const entries = Object.entries(aggFilter);
+    if (entries.length === 0) continue;
+    const expr = aggExprForField(aggKey, fieldName, alias);
+    for (const [op, val] of entries) {
+      if (op === "mode") continue;
+      const built = buildSimpleComparison(expr, op, val, params, dialect);
+      if (built && built.trim().length > 0) out.push(built);
+    }
+  }
+  return out;
+}
+function buildHavingClause(having, alias, params, model, dialect) {
+  if (!isNotNullish(having)) return "";
+  const d = dialect != null ? dialect : getGlobalDialect();
+  if (!isPlainObject(having)) return "";
+  return buildHavingNode(having, alias, params, d, model);
+}
+function normalizeCountArg(v) {
+  if (!isNotNullish(v)) return void 0;
+  if (v === true) return true;
+  if (isPlainObject(v)) return v;
+  return void 0;
+}
+function pushCountAllField(fields) {
+  fields.push(
+    `${SQL_TEMPLATES.COUNT_ALL} ${SQL_TEMPLATES.AS} ${quote("_count._all")}`
+  );
+}
+function assertCountableScalarField(fieldMap, model, fieldName) {
+  const field = fieldMap.get(fieldName);
+  if (!field) {
+    throw new Error(
+      `Field '${fieldName}' does not exist on model ${model.name}`
+    );
+  }
+  if (field.isRelation) {
+    throw new Error(
+      `Cannot use _count on relation field '${fieldName}' on model ${model.name}`
+    );
+  }
+}
+function pushCountField(fields, alias, fieldName) {
+  const outAlias = `_count.${fieldName}`;
+  fields.push(
+    `COUNT(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+  );
+}
+function addCountFields(fields, countArg, alias, model, fieldMap) {
+  if (!isNotNullish(countArg)) return;
+  if (countArg === true) {
+    pushCountAllField(fields);
+    return;
+  }
+  if (!isPlainObject(countArg)) return;
+  if (countArg._all === true) {
+    pushCountAllField(fields);
+  }
+  const selected = Object.entries(countArg).filter(
+    ([f, v]) => f !== "_all" && isTruthySelection(v)
+  );
+  for (const [f] of selected) {
+    assertCountableScalarField(fieldMap, model, f);
+    pushCountField(fields, alias, f);
+  }
+}
+function getAggregateSelectionObject(args, agg) {
+  const obj = args[agg];
+  return isPlainObject(obj) ? obj : void 0;
+}
+function assertAggregatableScalarField(fieldMap, model, agg, fieldName) {
+  const field = fieldMap.get(fieldName);
+  if (!field) {
+    throw new Error(
+      `Field '${fieldName}' does not exist on model ${model.name}`
+    );
+  }
+  if (field.isRelation) {
+    throw new Error(
+      `Cannot use ${agg} on relation field '${fieldName}' on model ${model.name}`
+    );
+  }
+  return field;
+}
+function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName) {
+  const outAlias = `${agg}.${fieldName}`;
+  fields.push(
+    `${aggFn}(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+  );
+}
+function addAggregateFields(fields, args, alias, model, fieldMap) {
+  for (const [agg, aggFn] of AGGREGATES) {
+    const obj = getAggregateSelectionObject(args, agg);
+    if (!obj) continue;
+    for (const [fieldName, selection] of Object.entries(obj)) {
+      if (fieldName === "_all")
+        throw new Error(`'${agg}' does not support '_all'`);
+      if (!isTruthySelection(selection)) continue;
+      const field = assertAggregatableScalarField(
+        fieldMap,
+        model,
+        agg,
+        fieldName
+      );
+      assertAggregateFieldType(agg, field.type, fieldName, model.name);
+      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName);
+    }
+  }
+}
+function buildAggregateFields(args, alias, model) {
+  const fields = [];
+  const fieldMap = getModelFieldMap(model);
+  const countArg = normalizeCountArg(args._count);
+  addCountFields(fields, countArg, alias, model, fieldMap);
+  addAggregateFields(fields, args, alias, model, fieldMap);
+  return fields;
+}
+function buildAggregateSql(args, whereResult, tableName, alias, model) {
+  assertSafeAlias(alias);
+  assertSafeTableRef(tableName);
+  const aggFields = buildAggregateFields(args, alias, model);
+  if (!isNonEmptyArray(aggFields)) {
+    throw new Error("buildAggregateSql requires at least one aggregate field");
+  }
+  const selectClause = aggFields.join(SQL_SEPARATORS.FIELD_LIST);
+  const whereClause = isValidWhereClause(whereResult.clause) ? `${SQL_TEMPLATES.WHERE} ${whereResult.clause}` : "";
+  const sql = [
+    SQL_TEMPLATES.SELECT,
+    selectClause,
+    SQL_TEMPLATES.FROM,
+    tableName,
+    alias,
+    whereClause
+  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+  validateSelectQuery(sql);
+  validateParamConsistency(sql, whereResult.params);
+  return Object.freeze({
+    sql,
+    params: Object.freeze([...whereResult.params]),
+    paramMappings: Object.freeze([...whereResult.paramMappings])
+  });
+}
+function assertGroupByBy(args, model) {
+  if (!isNotNullish(args.by) || !isNonEmptyArray(args.by)) {
+    throw new Error("buildGroupBySql: by is required and cannot be empty");
+  }
+  const byFields = args.by.map((f) => String(f));
+  const bySet = new Set(byFields);
+  if (bySet.size !== byFields.length) {
+    throw new Error("buildGroupBySql: by must not contain duplicates");
+  }
+  const modelFieldMap = getModelFieldMap(model);
+  for (const f of byFields) {
+    const field = modelFieldMap.get(f);
+    if (!field) {
+      throw new Error(
+        `groupBy.by references unknown field '${f}' on model ${model.name}`
+      );
+    }
+    if (field.isRelation) {
+      throw new Error(
+        `groupBy.by does not support relation field '${f}' on model ${model.name}`
+      );
+    }
+  }
+  return byFields;
+}
+function buildGroupBySelectParts(args, alias, model, byFields) {
+  const groupCols = byFields.map((f) => col(alias, f));
+  const groupFields = groupCols.join(SQL_SEPARATORS.FIELD_LIST);
+  const aggFields = buildAggregateFields(args, alias, model);
+  const selectFields = isNonEmptyArray(aggFields) ? groupCols.concat(aggFields).join(SQL_SEPARATORS.FIELD_LIST) : groupCols.join(SQL_SEPARATORS.FIELD_LIST);
+  return { groupCols, groupFields, selectFields };
+}
+function buildGroupByHaving(args, alias, params, model, dialect) {
+  if (!isNotNullish(args.having)) return "";
+  if (!isPlainObject(args.having)) return "";
+  const h = buildHavingClause(args.having, alias, params, model, dialect);
+  if (!h || h.trim().length === 0) return "";
+  return `${SQL_TEMPLATES.HAVING} ${h}`;
+}
+function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
+  assertSafeAlias(alias);
+  assertSafeTableRef(tableName);
+  const byFields = assertGroupByBy(args, model);
+  const d = getGlobalDialect();
+  const params = createParamStore(whereResult.nextParamIndex);
+  const { groupFields, selectFields } = buildGroupBySelectParts(
+    args,
+    alias,
+    model,
+    byFields
+  );
+  const havingClause = buildGroupByHaving(args, alias, params, model, d);
+  const whereClause = isValidWhereClause(whereResult.clause) ? `${SQL_TEMPLATES.WHERE} ${whereResult.clause}` : "";
+  const sql = [
+    SQL_TEMPLATES.SELECT,
+    selectFields,
+    SQL_TEMPLATES.FROM,
+    tableName,
+    alias,
+    whereClause,
+    SQL_TEMPLATES.GROUP_BY,
+    groupFields,
+    havingClause
+  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+  const snapshot = params.snapshot();
+  validateSelectQuery(sql);
+  validateParamConsistency(sql, [...whereResult.params, ...snapshot.params]);
+  return Object.freeze({
+    sql,
+    params: Object.freeze([...whereResult.params, ...snapshot.params]),
+    paramMappings: Object.freeze([
+      ...whereResult.paramMappings,
+      ...snapshot.mappings
+    ])
+  });
+}
+function buildCountSql(whereResult, tableName, alias, skip, dialect) {
+  assertSafeAlias(alias);
+  assertSafeTableRef(tableName);
+  const d = getGlobalDialect();
+  const whereClause = isValidWhereClause(whereResult.clause) ? `${SQL_TEMPLATES.WHERE} ${whereResult.clause}` : "";
+  const params = createParamStore(whereResult.nextParamIndex);
+  const baseSubSelect = [
+    SQL_TEMPLATES.SELECT,
+    "1",
+    SQL_TEMPLATES.FROM,
+    tableName,
+    alias,
+    whereClause
+  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+  const normalizedSkip = normalizeSkipLike(skip);
+  const subSelect = applyCountSkip(baseSubSelect, normalizedSkip, params, d);
+  const sql = [
+    SQL_TEMPLATES.SELECT,
+    SQL_TEMPLATES.COUNT_ALL,
+    SQL_TEMPLATES.AS,
+    quote("_count._all"),
+    SQL_TEMPLATES.FROM,
+    `(${subSelect})`,
+    SQL_TEMPLATES.AS,
+    `"sub"`
+  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+  validateSelectQuery(sql);
+  const snapshot = params.snapshot();
+  const mergedParams = [...whereResult.params, ...snapshot.params];
+  validateParamConsistency(sql, mergedParams);
+  return Object.freeze({
+    sql,
+    params: Object.freeze(mergedParams),
+    paramMappings: Object.freeze([
+      ...whereResult.paramMappings,
+      ...snapshot.mappings
+    ])
+  });
+}
+function applyCountSkip(subSelect, normalizedSkip, params, dialect) {
+  const shouldApply = schemaParser.isDynamicParameter(normalizedSkip) || typeof normalizedSkip === "number" && normalizedSkip > 0;
+  if (!shouldApply) return subSelect;
+  const placeholder = addAutoScoped(params, normalizedSkip, "count.skip");
+  if (dialect === "sqlite") {
+    return `${subSelect} ${SQL_TEMPLATES.LIMIT} -1 ${SQL_TEMPLATES.OFFSET} ${placeholder}`;
+  }
+  return `${subSelect} ${SQL_TEMPLATES.OFFSET} ${placeholder}`;
+}
+function safeAlias(input) {
+  const raw = String(input).toLowerCase();
+  const cleaned = raw.replace(/[^a-z0-9_]/g, "_");
+  const startsOk = /^[a-z_]/.test(cleaned);
+  let base = startsOk ? cleaned : `_${cleaned}`;
+  base = base.length > 0 ? base : "_t";
+  if (SQL_RESERVED_WORDS.has(base)) {
+    base = `_${base}`;
+  }
+  return base;
+}
+function isPrismaMethod(v) {
+  return v === "findMany" || v === "findFirst" || v === "findUnique" || v === "aggregate" || v === "groupBy" || v === "count";
+}
+function getMethodFromProcessed(processed) {
+  const maybe = processed == null ? void 0 : processed.method;
+  if (isPrismaMethod(maybe)) return maybe;
+  return "findMany";
+}
+function buildSqlResult(args) {
+  const {
+    method,
+    processed,
+    whereResult,
+    tableName,
+    alias,
+    modelDef,
+    schemaModels,
+    dialect
+  } = args;
+  if (method === "aggregate") {
+    return buildAggregateSql(processed, whereResult, tableName, alias, modelDef);
+  }
+  if (method === "groupBy") {
+    return buildGroupBySql(processed, whereResult, tableName, alias, modelDef);
+  }
+  if (method === "count") {
+    return buildCountSql(
+      whereResult,
+      tableName,
+      alias,
+      processed.skip
+    );
+  }
+  return buildSelectSql({
+    method,
+    args: processed,
+    model: modelDef,
+    schemas: schemaModels,
+    from: { tableName, alias },
+    whereResult,
+    dialect
+  });
+}
+function normalizeSqlAndMappingsForDialect(sql, paramMappings, dialect) {
+  if (dialect !== "sqlite") return { sql, paramMappings };
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const m of paramMappings) byIndex.set(m.index, m);
+  const placeholderPositions = [];
+  const normalizedSql = sql.replace(/\$(\d+)/g, (_, num) => {
+    placeholderPositions.push(parseInt(num, 10));
+    return "?";
+  });
+  const expandedMappings = placeholderPositions.map(
+    (originalIndex, i) => {
+      const originalMapping = byIndex.get(originalIndex);
+      if (!originalMapping) {
+        throw new Error(
+          `CRITICAL: No mapping found for parameter $${originalIndex}`
+        );
+      }
+      return {
+        index: i + 1,
+        value: originalMapping.value,
+        dynamicName: originalMapping.dynamicName
+      };
+    }
+  );
+  return { sql: normalizedSql, paramMappings: expandedMappings };
+}
+function buildParamsFromMappings(mappings) {
+  const sorted = [...mappings].sort((a, b) => a.index - b.index);
+  return sorted.reduce(
+    (acc, m) => {
+      if (m.dynamicName !== void 0) {
+        acc.dynamicKeys.push(m.dynamicName);
+        return acc;
+      }
+      if (m.value !== void 0) {
+        acc.staticParams.push(m.value);
+        return acc;
+      }
+      throw new Error(
+        `CRITICAL: ParamMap ${m.index} has neither dynamicName nor value`
+      );
+    },
+    { staticParams: [], dynamicKeys: [] }
+  );
+}
+function resolveModelContext(directive) {
+  const { model, datamodel } = directive.context;
+  const schemaModels = schemaParser.convertDMMFToModels(datamodel);
+  const modelDef = getModelByName(schemaModels, model.name);
+  if (!modelDef) throw new Error(`Model ${model.name} not found in schema`);
+  return { schemaModels, modelDef };
+}
+function buildMainTableAndAlias(args) {
+  const { modelDef, dialect } = args;
+  const baseName = modelDef.tableName || modelDef.name;
+  return {
+    tableName: buildTableReference(
+      SQL_TEMPLATES.PUBLIC_SCHEMA,
+      baseName,
+      dialect
+    ),
+    alias: safeAlias(`${baseName}_main`)
+  };
+}
+function buildMainWhere(args) {
+  const { processed, alias, schemaModels, modelDef, dialect } = args;
+  return buildWhereClause(processed.where || {}, {
+    alias,
+    schemaModels,
+    model: modelDef,
+    path: ["where"],
+    isSubquery: false,
+    dialect
+  });
+}
+function buildAndNormalizeSql(args) {
+  const {
+    processed,
+    whereResult,
+    tableName,
+    alias,
+    modelDef,
+    schemaModels,
+    dialect
+  } = args;
+  const method = getMethodFromProcessed(processed);
+  const sqlResult = buildSqlResult({
+    method,
+    processed,
+    whereResult,
+    tableName,
+    alias,
+    modelDef,
+    schemaModels,
+    dialect
+  });
+  return normalizeSqlAndMappingsForDialect(
+    sqlResult.sql,
+    sqlResult.paramMappings,
+    dialect
+  );
+}
+function finalizeDirective(args) {
+  const { directive, normalizedSql, normalizedMappings } = args;
+  validateSqlPositions(normalizedSql, normalizedMappings, getGlobalDialect());
+  const { staticParams, dynamicKeys } = buildParamsFromMappings(normalizedMappings);
+  return {
+    header: directive.header,
+    sql: normalizedSql,
+    staticParams,
+    dynamicKeys,
+    paramMappings: normalizedMappings,
+    originalDirective: directive
+  };
+}
+function generateSQL(directive) {
+  const { query } = directive;
+  const { schemaModels, modelDef } = resolveModelContext(directive);
+  const dialect = getGlobalDialect();
+  const { tableName, alias } = buildMainTableAndAlias({ modelDef, dialect });
+  const whereResult = buildMainWhere({
+    processed: query.processed,
+    alias,
+    schemaModels,
+    modelDef,
+    dialect
+  });
+  const normalized = buildAndNormalizeSql({
+    processed: query.processed,
+    whereResult,
+    tableName,
+    alias,
+    modelDef,
+    schemaModels,
+    dialect
+  });
+  return finalizeDirective({
+    directive,
+    normalizedSql: normalized.sql,
+    normalizedMappings: normalized.paramMappings
+  });
+}
+function generateSQL2(directive) {
+  return generateSQL(directive);
+}
+
+// src/code-emitter.ts
+function generateClient(options) {
+  return __async(this, null, function* () {
+    const { datamodel, outputDir, config } = options;
+    setGlobalDialect(config.dialect);
+    const models = schemaParser.convertDMMFToModels(datamodel);
+    const directiveResults = schemaParser.processAllDirectives(
+      datamodel.models,
+      datamodel,
+      {
+        skipInvalid: config.skipInvalid
+      }
+    );
+    const queries = /* @__PURE__ */ new Map();
+    for (const [modelName, result] of directiveResults) {
+      if (result.directives.length === 0) continue;
+      const modelQueries = /* @__PURE__ */ new Map();
+      for (const directive of result.directives) {
+        try {
+          const sqlDirective = generateSQL2(directive);
+          const queryKey = JSON.stringify(
+            directive.query.original,
+            Object.keys(directive.query.original).sort()
+          );
+          modelQueries.set(queryKey, {
+            sql: sqlDirective.sql,
+            params: sqlDirective.staticParams,
+            dynamicKeys: sqlDirective.dynamicKeys,
+            paramMappings: sqlDirective.paramMappings
+          });
+        } catch (error) {
+          if (!config.skipInvalid) throw error;
+        }
+      }
+      if (modelQueries.size > 0) {
+        queries.set(modelName, modelQueries);
+      }
+    }
+    yield promises.mkdir(outputDir, { recursive: true });
+    const code = generateCode(models, queries, config.dialect);
+    yield promises.writeFile(path.join(outputDir, "index.ts"), code);
+    const totalQueries = Array.from(queries.values()).reduce(
+      (sum, m) => sum + m.size,
+      0
+    );
+    console.log(`\u2713 Generated ${queries.size} models, ${totalQueries} queries`);
+  });
+}
+function generateCode(models, queries, dialect) {
+  return `// Generated by @prisma-sql/generator - DO NOT EDIT
+import { buildSQL, transformQueryResults, type PrismaMethod } from 'prisma-sql'
+
+const MODELS = ${JSON.stringify(models, null, 2)}
+
+const QUERIES = ${formatQueries(queries)}
+
+const DIALECT = ${JSON.stringify(dialect)}
+
+function normalizeQuery(args: any): string {
+  if (!args) return '{}'
+  return JSON.stringify(args, Object.keys(args).sort())
+}
+
+function extractDynamicParams(args: any, dynamicKeys: string[]): unknown[] {
+  const params: unknown[] = []
+  
+  for (const key of dynamicKeys) {
+    const parts = key.split('.')
+    let value: any = args
+    
+    for (const part of parts) {
+      if (value === null || value === undefined) break
+      value = value[part]
+    }
+    
+    if (value === undefined) {
+      throw new Error(\`Missing required parameter: \${key}\`)
+    }
+    
+    params.push(value)
+  }
+  
+  return params
+}
+
+async function executeQuery(client: any, sql: string, params: unknown[]): Promise<unknown[]> {
+  if (DIALECT === 'postgres') {
+    return await client.unsafe(sql, params)
+  }
+  
+  const stmt = client.prepare(sql)
+  
+  if (sql.toUpperCase().includes('COUNT(*) AS')) {
+    return [stmt.get(...params)]
+  }
+  
+  return stmt.all(...params)
+}
+
+export function createExtension(config: {
+  postgres?: any
+  sqlite?: any
+  debug?: boolean
+  onQuery?: (info: {
+    model: string
+    method: string
+    sql: string
+    params: unknown[]
+    duration: number
+    prebaked: boolean
+  }) => void
+}) {
+  const { postgres, sqlite, debug, onQuery } = config
+
+  if (!postgres && !sqlite) {
+    throw new Error('Extension requires postgres or sqlite client')
+  }
+
+  const client = postgres || sqlite
+  const actualDialect = postgres ? 'postgres' : 'sqlite'
+
+  if (actualDialect !== DIALECT) {
+    throw new Error(\`Generated code is for \${DIALECT}, but you provided \${actualDialect}\`)
+  }
+
+  return (prisma: any) => {
+    const handleMethod = async function(this: any, method: PrismaMethod, args: any) {
+      const modelName = this?.name || this?.$name
+      const startTime = Date.now()
+
+      // Try prebaked query first
+      const queryKey = normalizeQuery(args)
+      const prebakedQuery = QUERIES[modelName]?.[queryKey]
+
+      let sql: string
+      let params: unknown[]
+      let prebaked = false
+
+      if (prebakedQuery) {
+        // \u26A1 Use prebaked SQL
+        sql = prebakedQuery.sql
+        params = [...prebakedQuery.params, ...extractDynamicParams(args, prebakedQuery.dynamicKeys)]
+        prebaked = true
+      } else {
+        // \u{1F528} Fall back to runtime generation
+        const model = MODELS.find((m: any) => m.name === modelName)
+        
+        if (!model) {
+          return this.$parent[modelName][method](args)
+        }
+
+        const result = buildSQL(model, MODELS, method, args, DIALECT)
+        sql = result.sql
+        params = result.params
+      }
+
+      if (debug) {
+        console.log(\`[\${DIALECT}] \${modelName}.\${method} \${prebaked ? '\u26A1 PREBAKED' : '\u{1F528} RUNTIME'}\`)
+        console.log('SQL:', sql)
+        console.log('Params:', params)
+      }
+
+      const results = await executeQuery(client, sql, params)
+      const duration = Date.now() - startTime
+
+      onQuery?.({
+        model: modelName,
+        method,
+        sql,
+        params,
+        duration,
+        prebaked,
+      })
+
+      return transformQueryResults(method, results)
+    }
+
+    return prisma.$extends({
+      name: 'prisma-sql-generated',
+      
+      client: {
+        $original: prisma,
+      },
+
+      model: {
+        $allModels: {
+          async findMany(args: any) {
+            return handleMethod.call(this, 'findMany', args)
+          },
+          async findFirst(args: any) {
+            return handleMethod.call(this, 'findFirst', args)
+          },
+          async findUnique(args: any) {
+            return handleMethod.call(this, 'findUnique', args)
+          },
+          async count(args: any) {
+            return handleMethod.call(this, 'count', args)
+          },
+          async aggregate(args: any) {
+            return handleMethod.call(this, 'aggregate', args)
+          },
+          async groupBy(args: any) {
+            return handleMethod.call(this, 'groupBy', args)
+          },
+        },
+      },
+    })
+  }
+}
+`;
+}
+function formatQueries(queries) {
+  const entries = [];
+  for (const [modelName, modelQueries] of queries) {
+    const queryEntries = [];
+    for (const [queryKey, query] of modelQueries) {
+      queryEntries.push(`  ${JSON.stringify(queryKey)}: {
+    sql: ${JSON.stringify(query.sql)},
+    params: ${JSON.stringify(query.params)},
+    dynamicKeys: ${JSON.stringify(query.dynamicKeys)},
+    paramMappings: ${JSON.stringify(query.paramMappings)},
+  }`);
+    }
+    entries.push(`  ${JSON.stringify(modelName)}: {
+${queryEntries.join(",\n")}
+  }`);
+  }
+  return `{
+${entries.join(",\n")}
+}`;
+}
+var { version } = require_package();
+function getDialectFromProvider(provider) {
+  const normalized = provider.toLowerCase();
+  if (normalized === "sqlite") return "sqlite";
+  if (normalized === "postgresql" || normalized === "postgres")
+    return "postgres";
+  throw new Error(
+    `Unsupported database provider: ${provider}. Supported: postgresql, postgres, sqlite`
+  );
+}
+generatorHelper.generatorHandler({
+  onManifest() {
+    return {
+      version,
+      defaultOutput: "../node_modules/.prisma/client/sql",
+      prettyName: "Prisma SQL Generator",
+      requiresGenerators: ["prisma-client-js"]
+    };
+  },
+  onGenerate(options) {
+    return __async(this, null, function* () {
+      var _a;
+      const { generator, dmmf, datasources } = options;
+      if (!datasources || datasources.length === 0) {
+        throw new Error("No datasource found in schema");
+      }
+      const autoDialect = getDialectFromProvider(datasources[0].provider);
+      const configDialect = generator.config.dialect;
+      const dialect = configDialect || autoDialect;
+      if (configDialect && configDialect !== autoDialect) {
+        internals.logger.warn(
+          `Generator dialect (${configDialect}) differs from datasource provider (${datasources[0].provider}). Using generator config: ${configDialect}`
+        );
+      }
+      const config = {
+        dialect,
+        skipInvalid: generator.config.skipInvalid === "true"
+      };
+      const outputDir = ((_a = generator.output) == null ? void 0 : _a.value) || "../node_modules/.prisma/client/sql";
+      internals.logger.info(`Generating SQL client to ${outputDir}`);
+      internals.logger.info(`Datasource: ${datasources[0].provider}`);
+      internals.logger.info(`Dialect: ${config.dialect}`);
+      internals.logger.info(`Skip invalid: ${config.skipInvalid}`);
+      yield generateClient({
+        datamodel: dmmf.datamodel,
+        outputDir,
+        config
+      });
+      internals.logger.info("\u2713 Generated SQL client successfully");
+    });
+  }
+});
+//# sourceMappingURL=generator.cjs.map
+//# sourceMappingURL=generator.cjs.map