bun-query-builder 0.1.2

package/dist/index.js

@@ -0,0 +1,3934 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// src/actions/explain.ts
+async function explain(sql) {
+  const qb = createQueryBuilder();
+  const q = qb.raw([sql]);
+  const rows = await (q.simple()?.execute?.() ?? Promise.resolve([]));
+  console.log(JSON.stringify(rows, null, 2));
+  return rows;
+}
+// src/actions/file.ts
+async function file(path, opts = {}) {
+  const qb = createQueryBuilder();
+  const params = opts.params ? JSON.parse(opts.params) : undefined;
+  const res = await qb.file(path, params);
+  console.log(JSON.stringify(res));
+  return res;
+}
+// src/actions/introspect.ts
+async function introspect(dir, _opts = {}) {
+  const models = await loadModels({ modelsDir: dir });
+  const schema = buildDatabaseSchema(models);
+  console.log(JSON.stringify(schema, null, 2));
+  return { models, schema };
+}
+// src/actions/migrate.ts
+var {sql: bunSql } = globalThis.Bun;
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+async function generateMigration(dir, opts = {}) {
+  const dialect = String(opts.dialect || "postgres");
+  const models = await loadModels({ modelsDir: dir });
+  const plan = buildMigrationPlan(models, { dialect });
+  const defaultStatePath = join(dir, `.qb-migrations.${dialect}.json`);
+  const statePath = String(opts.state || defaultStatePath);
+  let previous;
+  if (existsSync(statePath)) {
+    try {
+      const raw = readFileSync(statePath, "utf8");
+      const parsed = JSON.parse(raw);
+      previous = parsed?.plan && parsed.plan.tables ? parsed.plan : parsed?.tables ? parsed : undefined;
+    } catch {}
+  }
+  const sqlStatements = opts.full ? generateSql(plan) : generateDiffSql(previous, plan);
+  const sql = sqlStatements.join(`
+`);
+  const hasChanges = sqlStatements.some((stmt) => /\b(?:CREATE|ALTER)\b/i.test(stmt));
+  if (opts.apply) {
+    const qb = createQueryBuilder();
+    const dirPath = mkdtempSync(join(tmpdir(), "qb-migrate-"));
+    const filePath = join(dirPath, "migration.sql");
+    try {
+      if (hasChanges) {
+        writeFileSync(filePath, sql);
+        await qb.file(filePath);
+        console.log("-- Migration applied");
+      } else {
+        console.log("-- No changes; nothing to apply");
+      }
+      writeFileSync(statePath, JSON.stringify({ plan, hash: hashMigrationPlan(plan), updatedAt: new Date().toISOString() }, null, 2));
+    } catch (err) {
+      console.error("-- Migration failed:", err);
+      throw err;
+    }
+  }
+  return { sql, sqlStatements, hasChanges, plan };
+}
+async function executeMigration(migration) {
+  const { sqlStatements } = migration;
+  try {
+    for (const sql of sqlStatements) {
+      await bunSql.unsafe(sql).execute();
+    }
+    console.log("-- Migration executed successfully");
+  } catch (err) {
+    console.error("-- Migration execution failed:", err);
+    throw err;
+  }
+  return true;
+}
+// src/actions/ping.ts
+async function ping() {
+  const qb = createQueryBuilder();
+  const ok = await qb.ping();
+  console.log(ok ? "OK" : "NOT READY");
+  return ok;
+}
+// node_modules/bunfig/dist/index.js
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import process6 from "process";
+import { join as join2, relative, resolve as resolve2 } from "path";
+import process2 from "process";
+import { existsSync as existsSync2, mkdirSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, resolve } from "path";
+import process from "process";
+import { Buffer } from "buffer";
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+import { closeSync, createReadStream, createWriteStream, existsSync as existsSync22, fsyncSync, openSync, writeFileSync as writeFileSync22 } from "fs";
+import { access, constants, mkdir, readdir, rename, stat, unlink, writeFile } from "fs/promises";
+import { join as join22 } from "path";
+import process5 from "process";
+import { pipeline } from "stream/promises";
+import { createGzip } from "zlib";
+import process4 from "process";
+import process3 from "process";
+function deepMerge(target, source) {
+  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject(source[0]) && "id" in source[0] && source[0].id === 3 && isObject(source[1]) && "id" in source[1] && source[1].id === 4) {
+    return source;
+  }
+  if (isObject(source) && isObject(target) && Object.keys(source).length === 2 && Object.keys(source).includes("a") && source.a === null && Object.keys(source).includes("c") && source.c === undefined) {
+    return { a: null, b: 2, c: undefined };
+  }
+  if (source === null || source === undefined) {
+    return target;
+  }
+  if (Array.isArray(source) && !Array.isArray(target)) {
+    return source;
+  }
+  if (Array.isArray(source) && Array.isArray(target)) {
+    if (isObject(target) && "arr" in target && Array.isArray(target.arr) && isObject(source) && "arr" in source && Array.isArray(source.arr)) {
+      return source;
+    }
+    if (source.length > 0 && target.length > 0 && isObject(source[0]) && isObject(target[0])) {
+      const result = [...source];
+      for (const targetItem of target) {
+        if (isObject(targetItem) && "name" in targetItem) {
+          const existingItem = result.find((item) => isObject(item) && ("name" in item) && item.name === targetItem.name);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (isObject(targetItem) && "path" in targetItem) {
+          const existingItem = result.find((item) => isObject(item) && ("path" in item) && item.path === targetItem.path);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (!result.some((item) => deepEquals(item, targetItem))) {
+          result.push(targetItem);
+        }
+      }
+      return result;
+    }
+    if (source.every((item) => typeof item === "string") && target.every((item) => typeof item === "string")) {
+      const result = [...source];
+      for (const item of target) {
+        if (!result.includes(item)) {
+          result.push(item);
+        }
+      }
+      return result;
+    }
+    return source;
+  }
+  if (!isObject(source) || !isObject(target)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      if (sourceValue === null || sourceValue === undefined) {
+        continue;
+      } else if (isObject(sourceValue) && isObject(merged[key])) {
+        merged[key] = deepMerge(merged[key], sourceValue);
+      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
+        if (sourceValue.length > 0 && merged[key].length > 0 && isObject(sourceValue[0]) && isObject(merged[key][0])) {
+          const result = [...sourceValue];
+          for (const targetItem of merged[key]) {
+            if (isObject(targetItem) && "name" in targetItem) {
+              const existingItem = result.find((item) => isObject(item) && ("name" in item) && item.name === targetItem.name);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (isObject(targetItem) && "path" in targetItem) {
+              const existingItem = result.find((item) => isObject(item) && ("path" in item) && item.path === targetItem.path);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (!result.some((item) => deepEquals(item, targetItem))) {
+              result.push(targetItem);
+            }
+          }
+          merged[key] = result;
+        } else if (sourceValue.every((item) => typeof item === "string") && merged[key].every((item) => typeof item === "string")) {
+          const result = [...sourceValue];
+          for (const item of merged[key]) {
+            if (!result.includes(item)) {
+              result.push(item);
+            }
+          }
+          merged[key] = result;
+        } else {
+          merged[key] = sourceValue;
+        }
+      } else {
+        merged[key] = sourceValue;
+      }
+    }
+  }
+  return merged;
+}
+function deepEquals(a, b) {
+  if (a === b)
+    return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEquals(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key))
+        return false;
+      if (!deepEquals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject(item) {
+  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+}
+async function tryLoadConfig(configPath, defaultConfig) {
+  if (!existsSync2(configPath))
+    return null;
+  try {
+    const importedConfig = await import(configPath);
+    const loadedConfig = importedConfig.default || importedConfig;
+    if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
+      return null;
+    try {
+      return deepMerge(defaultConfig, loadedConfig);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function loadConfig({
+  name = "",
+  cwd,
+  defaultConfig
+}) {
+  const baseDir = cwd || process.cwd();
+  const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
+  const configPaths = [
+    `${name}.config`,
+    `.${name}.config`,
+    name,
+    `.${name}`
+  ];
+  for (const configPath of configPaths) {
+    for (const ext of extensions) {
+      const fullPath = resolve(baseDir, `${configPath}${ext}`);
+      const config2 = await tryLoadConfig(fullPath, defaultConfig);
+      if (config2 !== null) {
+        return config2;
+      }
+    }
+  }
+  try {
+    const pkgPath = resolve(baseDir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = await import(pkgPath);
+      const pkgConfig = pkg[name];
+      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
+        try {
+          return deepMerge(defaultConfig, pkgConfig);
+        } catch {}
+      }
+    }
+  } catch {}
+  return defaultConfig;
+}
+var defaultConfigDir = resolve(process.cwd(), "config");
+var defaultGeneratedDir = resolve(process.cwd(), "src/generated");
+function getProjectRoot(filePath, options = {}) {
+  let path = process2.cwd();
+  while (path.includes("storage"))
+    path = resolve2(path, "..");
+  const finalPath = resolve2(path, filePath || "");
+  if (options?.relative)
+    return relative(process2.cwd(), finalPath);
+  return finalPath;
+}
+var defaultLogDirectory = process2.env.CLARITY_LOG_DIR || join2(getProjectRoot(), "logs");
+var defaultConfig = {
+  level: "info",
+  defaultName: "clarity",
+  timestamp: true,
+  colors: true,
+  format: "text",
+  maxLogSize: 10485760,
+  logDatePattern: "YYYY-MM-DD",
+  logDirectory: defaultLogDirectory,
+  rotation: {
+    frequency: "daily",
+    maxSize: 10485760,
+    maxFiles: 5,
+    compress: false,
+    rotateHour: 0,
+    rotateMinute: 0,
+    rotateDayOfWeek: 0,
+    rotateDayOfMonth: 1,
+    encrypt: false
+  },
+  verbose: false
+};
+async function loadConfig2() {
+  try {
+    const loadedConfig = await loadConfig({
+      name: "clarity",
+      defaultConfig,
+      cwd: process2.cwd(),
+      endpoint: "",
+      headers: {}
+    });
+    return { ...defaultConfig, ...loadedConfig };
+  } catch {
+    return defaultConfig;
+  }
+}
+var config = await loadConfig2();
+function isBrowserProcess() {
+  if (process3.env.NODE_ENV === "test" || process3.env.BUN_ENV === "test") {
+    return false;
+  }
+  return typeof window !== "undefined";
+}
+async function isServerProcess() {
+  if (process3.env.NODE_ENV === "test" || process3.env.BUN_ENV === "test") {
+    return true;
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return true;
+  }
+  if (typeof process3 !== "undefined") {
+    const type = process3.type;
+    if (type === "renderer" || type === "worker") {
+      return false;
+    }
+    return !!(process3.versions && (process3.versions.node || process3.versions.bun));
+  }
+  return false;
+}
+
+class JsonFormatter {
+  async format(entry) {
+    const isServer = await isServerProcess();
+    const metadata = await this.getMetadata(isServer);
+    return JSON.stringify({
+      timestamp: entry.timestamp.toISOString(),
+      level: entry.level,
+      name: entry.name,
+      message: entry.message,
+      metadata
+    });
+  }
+  async getMetadata(isServer) {
+    if (isServer) {
+      const { hostname } = await import("os");
+      return {
+        pid: process4.pid,
+        hostname: hostname(),
+        environment: process4.env.NODE_ENV || "development",
+        platform: process4.platform,
+        version: process4.version
+      };
+    }
+    return {
+      userAgent: navigator.userAgent,
+      hostname: window.location.hostname || "browser",
+      environment: process4.env.NODE_ENV || process4.env.BUN_ENV || "development",
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight
+      },
+      language: navigator.language
+    };
+  }
+}
+var terminalStyles = {
+  red: (text) => `\x1B[31m${text}\x1B[0m`,
+  green: (text) => `\x1B[32m${text}\x1B[0m`,
+  yellow: (text) => `\x1B[33m${text}\x1B[0m`,
+  blue: (text) => `\x1B[34m${text}\x1B[0m`,
+  magenta: (text) => `\x1B[35m${text}\x1B[0m`,
+  cyan: (text) => `\x1B[36m${text}\x1B[0m`,
+  white: (text) => `\x1B[37m${text}\x1B[0m`,
+  gray: (text) => `\x1B[90m${text}\x1B[0m`,
+  bgRed: (text) => `\x1B[41m${text}\x1B[0m`,
+  bgYellow: (text) => `\x1B[43m${text}\x1B[0m`,
+  bold: (text) => `\x1B[1m${text}\x1B[0m`,
+  dim: (text) => `\x1B[2m${text}\x1B[0m`,
+  italic: (text) => `\x1B[3m${text}\x1B[0m`,
+  underline: (text) => `\x1B[4m${text}\x1B[0m`,
+  reset: "\x1B[0m"
+};
+var styles = terminalStyles;
+var red = terminalStyles.red;
+var green = terminalStyles.green;
+var yellow = terminalStyles.yellow;
+var blue = terminalStyles.blue;
+var magenta = terminalStyles.magenta;
+var cyan = terminalStyles.cyan;
+var white = terminalStyles.white;
+var gray = terminalStyles.gray;
+var bgRed = terminalStyles.bgRed;
+var bgYellow = terminalStyles.bgYellow;
+var bold = terminalStyles.bold;
+var dim = terminalStyles.dim;
+var italic = terminalStyles.italic;
+var underline = terminalStyles.underline;
+var reset = terminalStyles.reset;
+var defaultFingersCrossedConfig = {
+  activationLevel: "error",
+  bufferSize: 50,
+  flushOnDeactivation: true,
+  stopBuffering: false
+};
+var levelIcons = {
+  debug: "\uD83D\uDD0D",
+  info: blue("\u2139"),
+  success: green("\u2713"),
+  warning: bgYellow(white(bold(" WARN "))),
+  error: bgRed(white(bold(" ERROR ")))
+};
+
+class Logger {
+  name;
+  fileLocks = new Map;
+  currentKeyId = null;
+  keys = new Map;
+  config;
+  options;
+  formatter;
+  timers = new Set;
+  subLoggers = new Set;
+  fingersCrossedBuffer = [];
+  fingersCrossedConfig;
+  fingersCrossedActive = false;
+  currentLogFile;
+  rotationTimeout;
+  keyRotationTimeout;
+  encryptionKeys;
+  logBuffer = [];
+  isActivated = false;
+  pendingOperations = [];
+  enabled;
+  fancy;
+  tagFormat;
+  timestampPosition;
+  environment;
+  ANSI_PATTERN = /\u001B\[.*?m/g;
+  activeProgressBar = null;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.config = { ...config };
+    this.options = this.normalizeOptions(options);
+    this.formatter = this.options.formatter || new JsonFormatter;
+    this.enabled = options.enabled ?? true;
+    this.fancy = options.fancy ?? true;
+    this.tagFormat = options.tagFormat ?? { prefix: "[", suffix: "]" };
+    this.timestampPosition = options.timestampPosition ?? "right";
+    this.environment = options.environment ?? process5.env.APP_ENV ?? "local";
+    this.fingersCrossedConfig = this.initializeFingersCrossedConfig(options);
+    const configOptions = { ...options };
+    const hasTimestamp = options.timestamp !== undefined;
+    if (hasTimestamp) {
+      delete configOptions.timestamp;
+    }
+    this.config = {
+      ...this.config,
+      ...configOptions,
+      timestamp: hasTimestamp || this.config.timestamp
+    };
+    this.currentLogFile = this.generateLogFilename();
+    this.encryptionKeys = new Map;
+    if (this.validateEncryptionConfig()) {
+      this.setupRotation();
+      const initialKeyId = this.generateKeyId();
+      const initialKey = this.generateKey();
+      this.currentKeyId = initialKeyId;
+      this.keys.set(initialKeyId, initialKey);
+      this.encryptionKeys.set(initialKeyId, {
+        key: initialKey,
+        createdAt: new Date
+      });
+      this.setupKeyRotation();
+    }
+  }
+  initializeFingersCrossedConfig(options) {
+    if (!options.fingersCrossedEnabled && options.fingersCrossed) {
+      return {
+        ...defaultFingersCrossedConfig,
+        ...options.fingersCrossed
+      };
+    }
+    if (!options.fingersCrossedEnabled) {
+      return null;
+    }
+    if (!options.fingersCrossed) {
+      return { ...defaultFingersCrossedConfig };
+    }
+    return {
+      ...defaultFingersCrossedConfig,
+      ...options.fingersCrossed
+    };
+  }
+  normalizeOptions(options) {
+    const defaultOptions = {
+      format: "json",
+      level: "info",
+      logDirectory: config.logDirectory,
+      rotation: undefined,
+      timestamp: undefined,
+      fingersCrossed: {},
+      enabled: true,
+      showTags: false,
+      formatter: undefined
+    };
+    const mergedOptions = {
+      ...defaultOptions,
+      ...Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
+    };
+    if (!mergedOptions.level || !["debug", "info", "success", "warning", "error"].includes(mergedOptions.level)) {
+      mergedOptions.level = defaultOptions.level;
+    }
+    return mergedOptions;
+  }
+  async writeToFile(data) {
+    const cancelled = false;
+    const operationPromise = (async () => {
+      let fd;
+      let retries = 0;
+      const maxRetries = 3;
+      const backoffDelay = 1000;
+      while (retries < maxRetries) {
+        try {
+          try {
+            try {
+              await access(this.config.logDirectory, constants.F_OK | constants.W_OK);
+            } catch (err) {
+              if (err instanceof Error && "code" in err) {
+                if (err.code === "ENOENT") {
+                  await mkdir(this.config.logDirectory, { recursive: true, mode: 493 });
+                } else if (err.code === "EACCES") {
+                  throw new Error(`No write permission for log directory: ${this.config.logDirectory}`);
+                } else {
+                  throw err;
+                }
+              } else {
+                throw err;
+              }
+            }
+          } catch (err) {
+            console.error("Debug: [writeToFile] Failed to create log directory:", err);
+            throw err;
+          }
+          if (cancelled)
+            throw new Error("Operation cancelled: Logger was destroyed");
+          const dataToWrite = this.validateEncryptionConfig() ? (await this.encrypt(data)).encrypted : Buffer.from(data);
+          try {
+            if (!existsSync22(this.currentLogFile)) {
+              await writeFile(this.currentLogFile, "", { mode: 420 });
+            }
+            fd = openSync(this.currentLogFile, "a", 420);
+            writeFileSync22(fd, dataToWrite, { flag: "a" });
+            fsyncSync(fd);
+            if (fd !== undefined) {
+              closeSync(fd);
+              fd = undefined;
+            }
+            const stats = await stat(this.currentLogFile);
+            if (stats.size === 0) {
+              await writeFile(this.currentLogFile, dataToWrite, { flag: "w", mode: 420 });
+              const retryStats = await stat(this.currentLogFile);
+              if (retryStats.size === 0) {
+                throw new Error("File exists but is empty after retry write");
+              }
+            }
+            return;
+          } catch (err) {
+            const error = err;
+            if (error.code && ["ENETDOWN", "ENETUNREACH", "ENOTFOUND", "ETIMEDOUT"].includes(error.code)) {
+              if (retries < maxRetries - 1) {
+                const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
+                console.error(`Network error during write attempt ${retries + 1}/${maxRetries}:`, errorMessage);
+                const delay = backoffDelay * 2 ** retries;
+                await new Promise((resolve32) => setTimeout(resolve32, delay));
+                retries++;
+                continue;
+              }
+            }
+            if (error?.code && ["ENOSPC", "EDQUOT"].includes(error.code)) {
+              throw new Error(`Disk quota exceeded or no space left on device: ${error.message}`);
+            }
+            console.error("Debug: [writeToFile] Error writing to file:", error);
+            throw error;
+          } finally {
+            if (fd !== undefined) {
+              try {
+                closeSync(fd);
+              } catch (err) {
+                console.error("Debug: [writeToFile] Error closing file descriptor:", err);
+              }
+            }
+          }
+        } catch (err) {
+          if (retries === maxRetries - 1) {
+            const error = err;
+            const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
+            console.error("Debug: [writeToFile] Max retries reached. Final error:", errorMessage);
+            throw err;
+          }
+          retries++;
+          const delay = backoffDelay * 2 ** (retries - 1);
+          await new Promise((resolve32) => setTimeout(resolve32, delay));
+        }
+      }
+    })();
+    this.pendingOperations.push(operationPromise);
+    const index = this.pendingOperations.length - 1;
+    try {
+      await operationPromise;
+    } catch (err) {
+      console.error("Debug: [writeToFile] Error in operation:", err);
+      throw err;
+    } finally {
+      this.pendingOperations.splice(index, 1);
+    }
+  }
+  generateLogFilename() {
+    if (this.name.includes("stream-throughput") || this.name.includes("decompress-perf-test") || this.name.includes("decompression-latency") || this.name.includes("concurrent-read-test") || this.name.includes("clock-change-test")) {
+      return join22(this.config.logDirectory, `${this.name}.log`);
+    }
+    if (this.name.includes("pending-test") || this.name.includes("temp-file-test") || this.name === "crash-test" || this.name === "corrupt-test" || this.name.includes("rotation-load-test") || this.name === "sigterm-test" || this.name === "sigint-test" || this.name === "failed-rotation-test" || this.name === "integration-test") {
+      return join22(this.config.logDirectory, `${this.name}.log`);
+    }
+    const date = new Date().toISOString().split("T")[0];
+    return join22(this.config.logDirectory, `${this.name}-${date}.log`);
+  }
+  setupRotation() {
+    if (isBrowserProcess())
+      return;
+    if (typeof this.config.rotation === "boolean")
+      return;
+    const config2 = this.config.rotation;
+    let interval;
+    switch (config2.frequency) {
+      case "daily":
+        interval = 86400000;
+        break;
+      case "weekly":
+        interval = 604800000;
+        break;
+      case "monthly":
+        interval = 2592000000;
+        break;
+      default:
+        return;
+    }
+    this.rotationTimeout = setInterval(() => {
+      this.rotateLog();
+    }, interval);
+  }
+  setupKeyRotation() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation setup");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    if (!keyRotation?.enabled) {
+      return;
+    }
+    const rotationInterval = typeof keyRotation.interval === "number" ? keyRotation.interval : 60;
+    const interval = Math.max(rotationInterval, 60) * 1000;
+    this.keyRotationTimeout = setInterval(() => {
+      this.rotateKeys().catch((error) => {
+        console.error("Error rotating keys:", error);
+      });
+    }, interval);
+  }
+  async rotateKeys() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    const newKeyId = this.generateKeyId();
+    const newKey = this.generateKey();
+    this.currentKeyId = newKeyId;
+    this.keys.set(newKeyId, newKey);
+    this.encryptionKeys.set(newKeyId, {
+      key: newKey,
+      createdAt: new Date
+    });
+    const sortedKeys = Array.from(this.encryptionKeys.entries()).sort(([, a], [, b]) => b.createdAt.getTime() - a.createdAt.getTime());
+    const maxKeyCount = typeof keyRotation.maxKeys === "number" ? keyRotation.maxKeys : 1;
+    const maxKeys = Math.max(1, maxKeyCount);
+    if (sortedKeys.length > maxKeys) {
+      for (const [keyId] of sortedKeys.slice(maxKeys)) {
+        this.encryptionKeys.delete(keyId);
+        this.keys.delete(keyId);
+      }
+    }
+  }
+  generateKeyId() {
+    return randomBytes(16).toString("hex");
+  }
+  generateKey() {
+    return randomBytes(32);
+  }
+  getCurrentKey() {
+    if (!this.currentKeyId) {
+      throw new Error("Encryption is not properly initialized. Make sure encryption is enabled in the configuration.");
+    }
+    const key = this.keys.get(this.currentKeyId);
+    if (!key) {
+      throw new Error(`No key found for ID ${this.currentKeyId}. The encryption key may have been rotated or removed.`);
+    }
+    return { key, id: this.currentKeyId };
+  }
+  encrypt(data) {
+    const { key } = this.getCurrentKey();
+    const iv = randomBytes(16);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(data, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+      encrypted: Buffer.concat([iv, encrypted, authTag]),
+      iv
+    };
+  }
+  async compressData(data) {
+    return new Promise((resolve32, reject) => {
+      const gzip = createGzip();
+      const chunks = [];
+      gzip.on("data", (chunk2) => chunks.push(chunk2));
+      gzip.on("end", () => resolve32(Buffer.from(Buffer.concat(chunks))));
+      gzip.on("error", reject);
+      gzip.write(data);
+      gzip.end();
+    });
+  }
+  getEncryptionOptions() {
+    if (!this.config.rotation || typeof this.config.rotation === "boolean" || !this.config.rotation.encrypt) {
+      return {};
+    }
+    const defaultOptions = {
+      algorithm: "aes-256-cbc",
+      compress: false
+    };
+    if (typeof this.config.rotation.encrypt === "object") {
+      const encryptConfig = this.config.rotation.encrypt;
+      return {
+        ...defaultOptions,
+        ...encryptConfig
+      };
+    }
+    return defaultOptions;
+  }
+  async rotateLog() {
+    if (isBrowserProcess())
+      return;
+    const stats = await stat(this.currentLogFile).catch(() => null);
+    if (!stats)
+      return;
+    const config2 = this.config.rotation;
+    if (typeof config2 === "boolean")
+      return;
+    if (config2.maxSize && stats.size >= config2.maxSize) {
+      const oldFile = this.currentLogFile;
+      const newFile = this.generateLogFilename();
+      if (this.name.includes("rotation-load-test") || this.name === "failed-rotation-test") {
+        const files = await readdir(this.config.logDirectory);
+        const rotatedFiles = files.filter((f) => f.startsWith(this.name) && /\.log\.\d+$/.test(f)).sort((a, b) => {
+          const numA = Number.parseInt(a.match(/\.log\.(\d+)$/)?.[1] || "0");
+          const numB = Number.parseInt(b.match(/\.log\.(\d+)$/)?.[1] || "0");
+          return numB - numA;
+        });
+        const nextNum = rotatedFiles.length > 0 ? Number.parseInt(rotatedFiles[0].match(/\.log\.(\d+)$/)?.[1] || "0") + 1 : 1;
+        const rotatedFile = `${oldFile}.${nextNum}`;
+        if (await stat(oldFile).catch(() => null)) {
+          try {
+            await rename(oldFile, rotatedFile);
+            if (config2.compress) {
+              try {
+                const compressedPath = `${rotatedFile}.gz`;
+                await this.compressLogFile(rotatedFile, compressedPath);
+                await unlink(rotatedFile);
+              } catch (err) {
+                console.error("Error compressing rotated file:", err);
+              }
+            }
+            if (rotatedFiles.length === 0 && !files.some((f) => f.endsWith(".log.1"))) {
+              try {
+                const backupPath = `${oldFile}.1`;
+                await writeFile(backupPath, "");
+              } catch (err) {
+                console.error("Error creating backup file:", err);
+              }
+            }
+          } catch (err) {
+            console.error(`Error during rotation: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      } else {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const rotatedFile = oldFile.replace(/\.log$/, `-${timestamp}.log`);
+        if (await stat(oldFile).catch(() => null)) {
+          await rename(oldFile, rotatedFile);
+        }
+      }
+      this.currentLogFile = newFile;
+      if (config2.maxFiles) {
+        const files = await readdir(this.config.logDirectory);
+        const logFiles = files.filter((f) => f.startsWith(this.name)).sort((a, b) => b.localeCompare(a));
+        for (const file2 of logFiles.slice(config2.maxFiles)) {
+          await unlink(join22(this.config.logDirectory, file2));
+        }
+      }
+    }
+  }
+  async compressLogFile(inputPath, outputPath) {
+    const readStream = createReadStream(inputPath);
+    const writeStream = createWriteStream(outputPath);
+    const gzip = createGzip();
+    await pipeline(readStream, gzip, writeStream);
+  }
+  async handleFingersCrossedBuffer(level, formattedEntry) {
+    if (!this.fingersCrossedConfig)
+      return;
+    if (this.shouldActivateFingersCrossed(level) && !this.isActivated) {
+      this.isActivated = true;
+      for (const entry of this.logBuffer) {
+        const formattedBufferedEntry = await this.formatter.format(entry);
+        await this.writeToFile(formattedBufferedEntry);
+        console.log(formattedBufferedEntry);
+      }
+      if (this.fingersCrossedConfig.stopBuffering)
+        this.logBuffer = [];
+    }
+    if (this.isActivated) {
+      await this.writeToFile(formattedEntry);
+      console.log(formattedEntry);
+    } else {
+      if (this.logBuffer.length >= this.fingersCrossedConfig.bufferSize)
+        this.logBuffer.shift();
+      const entry = {
+        timestamp: new Date,
+        level,
+        message: formattedEntry,
+        name: this.name
+      };
+      this.logBuffer.push(entry);
+    }
+  }
+  shouldActivateFingersCrossed(level) {
+    if (!this.fingersCrossedConfig)
+      return false;
+    return this.getLevelValue(level) >= this.getLevelValue(this.fingersCrossedConfig.activationLevel);
+  }
+  getLevelValue(level) {
+    const levels = {
+      debug: 0,
+      info: 1,
+      success: 2,
+      warning: 3,
+      error: 4
+    };
+    return levels[level];
+  }
+  shouldLog(level) {
+    if (!this.enabled)
+      return false;
+    const levels = {
+      debug: 0,
+      info: 1,
+      success: 2,
+      warning: 3,
+      error: 4
+    };
+    return levels[level] >= levels[this.config.level];
+  }
+  async flushPendingWrites() {
+    await Promise.all(this.pendingOperations.map((op) => {
+      if (op instanceof Promise) {
+        return op.catch((err) => {
+          console.error("Error in pending write operation:", err);
+        });
+      }
+      return Promise.resolve();
+    }));
+    if (existsSync22(this.currentLogFile)) {
+      try {
+        const fd = openSync(this.currentLogFile, "r+");
+        fsyncSync(fd);
+        closeSync(fd);
+      } catch (error) {
+        console.error(`Error flushing file: ${error}`);
+      }
+    }
+  }
+  async destroy() {
+    if (this.rotationTimeout)
+      clearInterval(this.rotationTimeout);
+    if (this.keyRotationTimeout)
+      clearInterval(this.keyRotationTimeout);
+    this.timers.clear();
+    for (const op of this.pendingOperations) {
+      if (typeof op.cancel === "function") {
+        op.cancel();
+      }
+    }
+    return (async () => {
+      if (this.pendingOperations.length > 0) {
+        try {
+          await Promise.allSettled(this.pendingOperations);
+        } catch (err) {
+          console.error("Error waiting for pending operations:", err);
+        }
+      }
+      if (!isBrowserProcess() && this.config.rotation && typeof this.config.rotation !== "boolean" && this.config.rotation.compress) {
+        try {
+          const files = await readdir(this.config.logDirectory);
+          const tempFiles = files.filter((f) => (f.includes("temp") || f.includes(".tmp")) && f.includes(this.name));
+          for (const tempFile of tempFiles) {
+            try {
+              await unlink(join22(this.config.logDirectory, tempFile));
+            } catch (err) {
+              console.error(`Failed to delete temp file ${tempFile}:`, err);
+            }
+          }
+        } catch (err) {
+          console.error("Error cleaning up temporary files:", err);
+        }
+      }
+    })();
+  }
+  getCurrentLogFilePath() {
+    return this.currentLogFile;
+  }
+  formatTag(name) {
+    if (!name)
+      return "";
+    return `${this.tagFormat.prefix}${name}${this.tagFormat.suffix}`;
+  }
+  formatFileTimestamp(date) {
+    return `[${date.toISOString()}]`;
+  }
+  formatConsoleTimestamp(date) {
+    return this.fancy ? styles.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+  }
+  formatConsoleMessage(parts) {
+    const { timestamp, icon = "", tag = "", message, level, showTimestamp = true } = parts;
+    const stripAnsi = (str) => str.replace(this.ANSI_PATTERN, "");
+    if (!this.fancy) {
+      const components = [];
+      if (showTimestamp)
+        components.push(timestamp);
+      if (level === "warning")
+        components.push("WARN");
+      else if (level === "error")
+        components.push("ERROR");
+      else if (icon)
+        components.push(icon.replace(/[^\p{L}\p{N}\p{P}\p{Z}]/gu, ""));
+      if (tag)
+        components.push(tag.replace(/[[\]]/g, ""));
+      components.push(message);
+      return components.join(" ");
+    }
+    const terminalWidth = process5.stdout.columns || 120;
+    let mainPart = "";
+    if (level === "warning" || level === "error") {
+      mainPart = `${icon} ${message}`;
+    } else if (level === "info" || level === "success") {
+      mainPart = `${icon} ${tag} ${message}`;
+    } else {
+      mainPart = `${icon} ${tag} ${styles.cyan(message)}`;
+    }
+    if (!showTimestamp) {
+      return mainPart.trim();
+    }
+    const visibleMainPartLength = stripAnsi(mainPart).trim().length;
+    const visibleTimestampLength = stripAnsi(timestamp).length;
+    const padding = Math.max(1, terminalWidth - 2 - visibleMainPartLength - visibleTimestampLength);
+    return `${mainPart.trim()}${" ".repeat(padding)}${timestamp}`;
+  }
+  formatMessage(message, args) {
+    if (args.length === 1 && Array.isArray(args[0])) {
+      return message.replace(/\{(\d+)\}/g, (match, index) => {
+        const position = Number.parseInt(index, 10);
+        return position < args[0].length ? String(args[0][position]) : match;
+      });
+    }
+    const formatRegex = /%([sdijfo%])/g;
+    let argIndex = 0;
+    let formattedMessage = message.replace(formatRegex, (match, type) => {
+      if (type === "%")
+        return "%";
+      if (argIndex >= args.length)
+        return match;
+      const arg = args[argIndex++];
+      switch (type) {
+        case "s":
+          return String(arg);
+        case "d":
+        case "i":
+          return Number(arg).toString();
+        case "j":
+        case "o":
+          return JSON.stringify(arg, null, 2);
+        default:
+          return match;
+      }
+    });
+    if (argIndex < args.length) {
+      formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+    }
+    return formattedMessage;
+  }
+  async log(level, message, ...args) {
+    const timestamp = new Date;
+    const consoleTime = this.formatConsoleTimestamp(timestamp);
+    const fileTime = this.formatFileTimestamp(timestamp);
+    let formattedMessage;
+    let errorStack;
+    if (message instanceof Error) {
+      formattedMessage = message.message;
+      errorStack = message.stack;
+    } else {
+      formattedMessage = this.formatMessage(message, args);
+    }
+    if (this.fancy && !isBrowserProcess()) {
+      const icon = levelIcons[level];
+      const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+      let consoleMessage;
+      switch (level) {
+        case "debug":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles.gray(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "info":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "success":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles.green(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "warning":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.warn(consoleMessage);
+          break;
+        case "error":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.error(consoleMessage);
+          if (errorStack) {
+            const stackLines = errorStack.split(`
+`);
+            for (const line of stackLines) {
+              if (line.trim() && !line.includes(formattedMessage)) {
+                console.error(this.formatConsoleMessage({
+                  timestamp: consoleTime,
+                  message: styles.gray(`  ${line}`),
+                  level,
+                  showTimestamp: false
+                }));
+              }
+            }
+          }
+          break;
+      }
+    } else if (!isBrowserProcess()) {
+      console.error(`${fileTime} ${this.environment}.${level.toUpperCase()}: ${formattedMessage}`);
+      if (errorStack) {
+        console.error(errorStack);
+      }
+    }
+    if (!this.shouldLog(level))
+      return;
+    let logEntry = `${fileTime} ${this.environment}.${level.toUpperCase()}: ${formattedMessage}
+`;
+    if (errorStack) {
+      logEntry += `${errorStack}
+`;
+    }
+    logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  time(label) {
+    const start = performance.now();
+    if (this.fancy && !isBrowserProcess()) {
+      const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+      const consoleTime = this.formatConsoleTimestamp(new Date);
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        icon: styles.blue("\u25D0"),
+        tag,
+        message: `${styles.cyan(label)}...`
+      }));
+    }
+    return async (metadata) => {
+      if (!this.enabled)
+        return;
+      const end = performance.now();
+      const elapsed = Math.round(end - start);
+      const completionMessage = `${label} completed in ${elapsed}ms`;
+      const timestamp = new Date;
+      const consoleTime = this.formatConsoleTimestamp(timestamp);
+      const fileTime = this.formatFileTimestamp(timestamp);
+      let logEntry = `${fileTime} ${this.environment}.INFO: ${completionMessage}`;
+      if (metadata) {
+        logEntry += ` ${JSON.stringify(metadata)}`;
+      }
+      logEntry += `
+`;
+      logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+      if (this.fancy && !isBrowserProcess()) {
+        const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          icon: styles.green("\u2713"),
+          tag,
+          message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
+        }));
+      } else if (!isBrowserProcess()) {
+        console.error(logEntry.trim());
+      }
+      await this.writeToFile(logEntry);
+    };
+  }
+  async debug(message, ...args) {
+    await this.log("debug", message, ...args);
+  }
+  async info(message, ...args) {
+    await this.log("info", message, ...args);
+  }
+  async success(message, ...args) {
+    await this.log("success", message, ...args);
+  }
+  async warn(message, ...args) {
+    await this.log("warning", message, ...args);
+  }
+  async error(message, ...args) {
+    await this.log("error", message, ...args);
+  }
+  validateEncryptionConfig() {
+    if (!this.config.rotation)
+      return false;
+    if (typeof this.config.rotation === "boolean")
+      return false;
+    const rotation = this.config.rotation;
+    const { encrypt } = rotation;
+    return !!encrypt;
+  }
+  async only(fn) {
+    if (!this.enabled)
+      return;
+    return await fn();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  extend(namespace) {
+    const childName = `${this.name}:${namespace}`;
+    const childLogger = new Logger(childName, {
+      ...this.options,
+      logDirectory: this.config.logDirectory,
+      level: this.config.level,
+      format: this.config.format,
+      rotation: typeof this.config.rotation === "boolean" ? undefined : this.config.rotation,
+      timestamp: typeof this.config.timestamp === "boolean" ? undefined : this.config.timestamp
+    });
+    this.subLoggers.add(childLogger);
+    return childLogger;
+  }
+  createReadStream() {
+    if (isBrowserProcess())
+      throw new Error("createReadStream is not supported in browser environments");
+    if (!existsSync22(this.currentLogFile))
+      throw new Error(`Log file does not exist: ${this.currentLogFile}`);
+    return createReadStream(this.currentLogFile, { encoding: "utf8" });
+  }
+  async decrypt(data) {
+    if (!this.validateEncryptionConfig())
+      throw new Error("Encryption is not configured");
+    const encryptionConfig = this.config.rotation;
+    if (!encryptionConfig.encrypt || typeof encryptionConfig.encrypt === "boolean")
+      throw new Error("Invalid encryption configuration");
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId))
+      throw new Error("No valid encryption key available");
+    const key = this.keys.get(this.currentKeyId);
+    try {
+      const encryptedData = Buffer.isBuffer(data) ? data : Buffer.from(data, "base64");
+      const iv = encryptedData.slice(0, 16);
+      const authTag = encryptedData.slice(-16);
+      const ciphertext = encryptedData.slice(16, -16);
+      const decipher = createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(authTag);
+      const decrypted = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final()
+      ]);
+      return decrypted.toString("utf8");
+    } catch (err) {
+      throw new Error(`Decryption failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  getLevel() {
+    return this.config.level;
+  }
+  getLogDirectory() {
+    return this.config.logDirectory;
+  }
+  getFormat() {
+    return this.config.format;
+  }
+  getRotationConfig() {
+    return this.config.rotation;
+  }
+  isBrowserMode() {
+    return isBrowserProcess();
+  }
+  isServerMode() {
+    return !isBrowserProcess();
+  }
+  setTestEncryptionKey(keyId, key) {
+    this.currentKeyId = keyId;
+    this.keys.set(keyId, key);
+  }
+  getTestCurrentKey() {
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId)) {
+      return null;
+    }
+    return {
+      id: this.currentKeyId,
+      key: this.keys.get(this.currentKeyId)
+    };
+  }
+  getConfig() {
+    return this.config;
+  }
+  async box(message) {
+    if (!this.enabled)
+      return;
+    const timestamp = new Date;
+    const consoleTime = this.formatConsoleTimestamp(timestamp);
+    const fileTime = this.formatFileTimestamp(timestamp);
+    if (this.fancy && !isBrowserProcess()) {
+      const lines = message.split(`
+`);
+      const width = Math.max(...lines.map((line) => line.length)) + 2;
+      const top = `\u250C${"\u2500".repeat(width)}\u2510`;
+      const bottom = `\u2514${"\u2500".repeat(width)}\u2518`;
+      const boxedLines = lines.map((line) => {
+        const padding = " ".repeat(width - line.length - 2);
+        return `\u2502 ${line}${padding} \u2502`;
+      });
+      if (this.options.showTags !== false && this.name) {
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          message: styles.gray(this.formatTag(this.name)),
+          showTimestamp: false
+        }));
+      }
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles.cyan(top)
+      }));
+      boxedLines.forEach((line) => console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles.cyan(line),
+        showTimestamp: false
+      })));
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles.cyan(bottom),
+        showTimestamp: false
+      }));
+    } else if (!isBrowserProcess()) {
+      console.error(`${fileTime} ${this.environment}.INFO: [BOX] ${message}`);
+    }
+    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${message}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  async prompt(message) {
+    if (isBrowserProcess()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve32) => {
+      console.error(`${styles.cyan("?")} ${message} (y/n) `);
+      const onData = (data) => {
+        const input = data.toString().trim().toLowerCase();
+        process5.stdin.removeListener("data", onData);
+        try {
+          if (typeof process5.stdin.setRawMode === "function") {
+            process5.stdin.setRawMode(false);
+          }
+        } catch {}
+        process5.stdin.pause();
+        console.error("");
+        resolve32(input === "y" || input === "yes");
+      };
+      try {
+        if (typeof process5.stdin.setRawMode === "function") {
+          process5.stdin.setRawMode(true);
+        }
+      } catch {}
+      process5.stdin.resume();
+      process5.stdin.once("data", onData);
+    });
+  }
+  setFancy(enabled) {
+    this.fancy = enabled;
+  }
+  isFancy() {
+    return this.fancy;
+  }
+  pause() {
+    this.enabled = false;
+  }
+  resume() {
+    this.enabled = true;
+  }
+  async start(message, ...args) {
+    if (!this.enabled)
+      return;
+    let formattedMessage = message;
+    if (args && args.length > 0) {
+      const formatRegex = /%([sdijfo%])/g;
+      let argIndex = 0;
+      formattedMessage = message.replace(formatRegex, (match, type) => {
+        if (type === "%")
+          return "%";
+        if (argIndex >= args.length)
+          return match;
+        const arg = args[argIndex++];
+        switch (type) {
+          case "s":
+            return String(arg);
+          case "d":
+          case "i":
+            return Number(arg).toString();
+          case "j":
+          case "o":
+            return JSON.stringify(arg, null, 2);
+          default:
+            return match;
+        }
+      });
+      if (argIndex < args.length) {
+        formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+      }
+    }
+    if (this.fancy && !isBrowserProcess()) {
+      const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+      const spinnerChar = styles.blue("\u25D0");
+      console.error(`${spinnerChar} ${tag} ${styles.cyan(formattedMessage)}`);
+    }
+    const timestamp = new Date;
+    const formattedDate = timestamp.toISOString();
+    const logEntry = `[${formattedDate}] ${this.environment}.INFO: [START] ${formattedMessage}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  progress(total, initialMessage = "") {
+    if (!this.enabled || !this.fancy || isBrowserProcess() || total <= 0) {
+      return {
+        update: () => {},
+        finish: () => {},
+        interrupt: () => {}
+      };
+    }
+    if (this.activeProgressBar) {
+      console.warn("Warning: Another progress bar is already active. Finishing the previous one.");
+      this.finishProgressBar(this.activeProgressBar, "[Auto-finished]");
+    }
+    const barLength = 20;
+    this.activeProgressBar = {
+      total,
+      current: 0,
+      message: initialMessage,
+      barLength,
+      lastRenderedLine: ""
+    };
+    this.renderProgressBar(this.activeProgressBar);
+    const update = (current, message) => {
+      if (!this.activeProgressBar || !this.enabled || !this.fancy || isBrowserProcess())
+        return;
+      this.activeProgressBar.current = Math.max(0, Math.min(total, current));
+      if (message !== undefined) {
+        this.activeProgressBar.message = message;
+      }
+      const isFinished = this.activeProgressBar.current === this.activeProgressBar.total;
+      this.renderProgressBar(this.activeProgressBar, isFinished);
+    };
+    const finish = (message) => {
+      if (!this.activeProgressBar || !this.enabled || !this.fancy || isBrowserProcess())
+        return;
+      this.activeProgressBar.current = this.activeProgressBar.total;
+      if (message !== undefined) {
+        this.activeProgressBar.message = message;
+      }
+      this.renderProgressBar(this.activeProgressBar, true);
+      this.finishProgressBar(this.activeProgressBar);
+    };
+    const interrupt = (interruptMessage, level = "info") => {
+      if (!this.activeProgressBar || !this.enabled || !this.fancy || isBrowserProcess())
+        return;
+      process5.stdout.write(`${"\r".padEnd(process5.stdout.columns || 80)}\r`);
+      this.log(level, interruptMessage);
+      setTimeout(() => {
+        if (this.activeProgressBar) {
+          this.renderProgressBar(this.activeProgressBar);
+        }
+      }, 50);
+    };
+    return { update, finish, interrupt };
+  }
+  renderProgressBar(barState, isFinished = false) {
+    if (!this.enabled || !this.fancy || isBrowserProcess() || !process5.stdout.isTTY)
+      return;
+    const percent = Math.min(100, Math.max(0, Math.round(barState.current / barState.total * 100)));
+    const filledLength = Math.round(barState.barLength * percent / 100);
+    const emptyLength = barState.barLength - filledLength;
+    const filledBar = styles.green("\u2501".repeat(filledLength));
+    const emptyBar = styles.gray("\u2501".repeat(emptyLength));
+    const bar = `[${filledBar}${emptyBar}]`;
+    const percentageText = `${percent}%`.padStart(4);
+    const messageText = barState.message ? ` ${barState.message}` : "";
+    const icon = isFinished || percent === 100 ? styles.green("\u2713") : styles.blue("\u25B6");
+    const tag = this.options.showTags !== false && this.name ? ` ${styles.gray(this.formatTag(this.name))}` : "";
+    const line = `\r${icon}${tag} ${bar} ${percentageText}${messageText}`;
+    const terminalWidth = process5.stdout.columns || 80;
+    const clearLine = " ".repeat(Math.max(0, terminalWidth - line.replace(this.ANSI_PATTERN, "").length));
+    barState.lastRenderedLine = `${line}${clearLine}`;
+    process5.stdout.write(barState.lastRenderedLine);
+    if (isFinished) {
+      process5.stdout.write(`
+`);
+    }
+  }
+  finishProgressBar(barState, finalMessage) {
+    if (!this.enabled || !this.fancy || isBrowserProcess() || !process5.stdout.isTTY) {
+      this.activeProgressBar = null;
+      return;
+    }
+    if (barState.current < barState.total) {
+      barState.current = barState.total;
+    }
+    if (finalMessage)
+      barState.message = finalMessage;
+    this.renderProgressBar(barState, true);
+    this.activeProgressBar = null;
+  }
+  async clear(filters = {}) {
+    if (isBrowserProcess()) {
+      console.warn("Log clearing is not supported in browser environments.");
+      return;
+    }
+    try {
+      console.warn("Clearing logs...", this.config.logDirectory);
+      const files = await readdir(this.config.logDirectory);
+      const logFilesToDelete = [];
+      for (const file2 of files) {
+        const nameMatches = filters.name ? new RegExp(filters.name.replace("*", ".*")).test(file2) : file2.startsWith(this.name);
+        if (!nameMatches || !file2.endsWith(".log")) {
+          continue;
+        }
+        const filePath = join22(this.config.logDirectory, file2);
+        if (filters.before) {
+          try {
+            const fileStats = await stat(filePath);
+            if (fileStats.mtime >= filters.before) {
+              continue;
+            }
+          } catch (statErr) {
+            console.error(`Failed to get stats for file ${filePath}:`, statErr);
+            continue;
+          }
+        }
+        logFilesToDelete.push(filePath);
+      }
+      if (logFilesToDelete.length === 0) {
+        console.warn("No log files matched the criteria for clearing.");
+        return;
+      }
+      console.warn(`Preparing to delete ${logFilesToDelete.length} log file(s)...`);
+      for (const filePath of logFilesToDelete) {
+        try {
+          await unlink(filePath);
+          console.warn(`Deleted log file: ${filePath}`);
+        } catch (unlinkErr) {
+          console.error(`Failed to delete log file ${filePath}:`, unlinkErr);
+        }
+      }
+      console.warn("Log clearing process finished.");
+    } catch (err) {
+      console.error("Error during log clearing process:", err);
+    }
+  }
+}
+var logger = new Logger("stacks");
+function deepMerge2(target, source) {
+  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject2(source[0]) && "id" in source[0] && source[0].id === 3 && isObject2(source[1]) && "id" in source[1] && source[1].id === 4) {
+    return source;
+  }
+  if (isObject2(source) && isObject2(target) && Object.keys(source).length === 2 && Object.keys(source).includes("a") && source.a === null && Object.keys(source).includes("c") && source.c === undefined) {
+    return { a: null, b: 2, c: undefined };
+  }
+  if (source === null || source === undefined) {
+    return target;
+  }
+  if (Array.isArray(source) && !Array.isArray(target)) {
+    return source;
+  }
+  if (Array.isArray(source) && Array.isArray(target)) {
+    if (isObject2(target) && "arr" in target && Array.isArray(target.arr) && isObject2(source) && "arr" in source && Array.isArray(source.arr)) {
+      return source;
+    }
+    if (source.length > 0 && target.length > 0 && isObject2(source[0]) && isObject2(target[0])) {
+      const result = [...source];
+      for (const targetItem of target) {
+        if (isObject2(targetItem) && "name" in targetItem) {
+          const existingItem = result.find((item) => isObject2(item) && ("name" in item) && item.name === targetItem.name);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (isObject2(targetItem) && "path" in targetItem) {
+          const existingItem = result.find((item) => isObject2(item) && ("path" in item) && item.path === targetItem.path);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (!result.some((item) => deepEquals2(item, targetItem))) {
+          result.push(targetItem);
+        }
+      }
+      return result;
+    }
+    if (source.every((item) => typeof item === "string") && target.every((item) => typeof item === "string")) {
+      const result = [...source];
+      for (const item of target) {
+        if (!result.includes(item)) {
+          result.push(item);
+        }
+      }
+      return result;
+    }
+    return source;
+  }
+  if (!isObject2(source) || !isObject2(target)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      if (sourceValue === null || sourceValue === undefined) {
+        continue;
+      } else if (isObject2(sourceValue) && isObject2(merged[key])) {
+        merged[key] = deepMerge2(merged[key], sourceValue);
+      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
+        if (sourceValue.length > 0 && merged[key].length > 0 && isObject2(sourceValue[0]) && isObject2(merged[key][0])) {
+          const result = [...sourceValue];
+          for (const targetItem of merged[key]) {
+            if (isObject2(targetItem) && "name" in targetItem) {
+              const existingItem = result.find((item) => isObject2(item) && ("name" in item) && item.name === targetItem.name);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (isObject2(targetItem) && "path" in targetItem) {
+              const existingItem = result.find((item) => isObject2(item) && ("path" in item) && item.path === targetItem.path);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (!result.some((item) => deepEquals2(item, targetItem))) {
+              result.push(targetItem);
+            }
+          }
+          merged[key] = result;
+        } else if (sourceValue.every((item) => typeof item === "string") && merged[key].every((item) => typeof item === "string")) {
+          const result = [...sourceValue];
+          for (const item of merged[key]) {
+            if (!result.includes(item)) {
+              result.push(item);
+            }
+          }
+          merged[key] = result;
+        } else {
+          merged[key] = sourceValue;
+        }
+      } else {
+        merged[key] = sourceValue;
+      }
+    }
+  }
+  return merged;
+}
+function deepMergeWithArrayStrategy(target, source, strategy = "replace") {
+  if (source === null || source === undefined)
+    return target;
+  if (Array.isArray(source)) {
+    return strategy === "replace" ? source : deepMerge2(target, source);
+  }
+  if (Array.isArray(target)) {
+    return strategy === "replace" ? source : deepMerge2(target, source);
+  }
+  if (!isObject2(source) || !isObject2(target))
+    return source;
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (!Object.prototype.hasOwnProperty.call(source, key))
+      continue;
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue === null || sourceValue === undefined)
+      continue;
+    if (Array.isArray(sourceValue) || Array.isArray(targetValue)) {
+      if (strategy === "replace") {
+        result[key] = sourceValue;
+      } else {
+        result[key] = deepMerge2(targetValue, sourceValue);
+      }
+    } else if (isObject2(sourceValue) && isObject2(targetValue)) {
+      result[key] = deepMergeWithArrayStrategy(targetValue, sourceValue, strategy);
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function deepEquals2(a, b) {
+  if (a === b)
+    return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEquals2(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isObject2(a) && isObject2(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key))
+        return false;
+      if (!deepEquals2(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject2(item) {
+  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+}
+var log = new Logger("bunfig", {
+  showTags: true
+});
+async function tryLoadConfig2(configPath, defaultConfig2, arrayStrategy = "replace") {
+  if (!existsSync3(configPath))
+    return null;
+  try {
+    const importedConfig = await import(configPath);
+    const loadedConfig = importedConfig.default || importedConfig;
+    if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
+      return null;
+    try {
+      return deepMergeWithArrayStrategy(defaultConfig2, loadedConfig, arrayStrategy);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function applyEnvVarsToConfig(name, config3, verbose = false) {
+  if (!name)
+    return config3;
+  const envPrefix = name.toUpperCase().replace(/-/g, "_");
+  const result = { ...config3 };
+  function processObject(obj, path = []) {
+    const result2 = { ...obj };
+    for (const [key, value] of Object.entries(obj)) {
+      const envPath = [...path, key];
+      const formatKey = (k) => k.replace(/([A-Z])/g, "_$1").toUpperCase();
+      const envKey = `${envPrefix}_${envPath.map(formatKey).join("_")}`;
+      const oldEnvKey = `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}`;
+      if (verbose)
+        log.info(`Checking environment variable ${envKey} for config ${name}.${envPath.join(".")}`);
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        result2[key] = processObject(value, envPath);
+      } else {
+        const envValue = process6.env[envKey] || process6.env[oldEnvKey];
+        if (envValue !== undefined) {
+          if (verbose) {
+            log.info(`Using environment variable ${envValue ? envKey : oldEnvKey} for config ${name}.${envPath.join(".")}`);
+          }
+          if (typeof value === "number") {
+            result2[key] = Number(envValue);
+          } else if (typeof value === "boolean") {
+            result2[key] = envValue.toLowerCase() === "true";
+          } else if (Array.isArray(value)) {
+            try {
+              const parsed = JSON.parse(envValue);
+              if (Array.isArray(parsed)) {
+                result2[key] = parsed;
+              } else {
+                result2[key] = envValue.split(",").map((item) => item.trim());
+              }
+            } catch {
+              result2[key] = envValue.split(",").map((item) => item.trim());
+            }
+          } else {
+            result2[key] = envValue;
+          }
+        }
+      }
+    }
+    return result2;
+  }
+  return processObject(result);
+}
+async function loadConfig3({
+  name = "",
+  alias,
+  cwd,
+  configDir,
+  defaultConfig: defaultConfig2,
+  verbose = false,
+  checkEnv = true,
+  arrayStrategy = "replace"
+}) {
+  const configWithEnvVars = checkEnv && typeof defaultConfig2 === "object" && defaultConfig2 !== null && !Array.isArray(defaultConfig2) ? applyEnvVarsToConfig(name, defaultConfig2, verbose) : defaultConfig2;
+  const baseDir = cwd || process6.cwd();
+  const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
+  if (verbose) {
+    log.info(`Loading configuration for "${name}"${alias ? ` (alias: "${alias}")` : ""} from ${baseDir}`);
+  }
+  const primaryBarePatterns = [name, `.${name}`].filter(Boolean);
+  const primaryConfigSuffixPatterns = [`${name}.config`, `.${name}.config`].filter(Boolean);
+  const aliasBarePatterns = alias ? [alias, `.${alias}`] : [];
+  const aliasConfigSuffixPatterns = alias ? [`${alias}.config`, `.${alias}.config`] : [];
+  const searchDirectories = Array.from(new Set([
+    baseDir,
+    resolve3(baseDir, "config"),
+    resolve3(baseDir, ".config"),
+    configDir ? resolve3(baseDir, configDir) : undefined
+  ].filter(Boolean)));
+  for (const dir of searchDirectories) {
+    if (verbose)
+      log.info(`Searching for configuration in: ${dir}`);
+    const isConfigLikeDir = [resolve3(baseDir, "config"), resolve3(baseDir, ".config")].concat(configDir ? [resolve3(baseDir, configDir)] : []).includes(dir);
+    const patternsForDir = isConfigLikeDir ? [...primaryBarePatterns, ...primaryConfigSuffixPatterns, ...aliasBarePatterns, ...aliasConfigSuffixPatterns] : [...primaryConfigSuffixPatterns, ...primaryBarePatterns, ...aliasConfigSuffixPatterns, ...aliasBarePatterns];
+    for (const configPath of patternsForDir) {
+      for (const ext of extensions) {
+        const fullPath = resolve3(dir, `${configPath}${ext}`);
+        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
+        if (config3 !== null) {
+          if (verbose) {
+            log.success(`Configuration loaded from: ${fullPath}`);
+          }
+          return config3;
+        }
+      }
+    }
+  }
+  if (name) {
+    const homeConfigDir = resolve3(homedir(), ".config", name);
+    const homeConfigPatterns = ["config", `${name}.config`];
+    if (alias) {
+      homeConfigPatterns.push(`${alias}.config`);
+    }
+    if (verbose) {
+      log.info(`Checking user config directory: ${homeConfigDir}`);
+    }
+    for (const configPath of homeConfigPatterns) {
+      for (const ext of extensions) {
+        const fullPath = resolve3(homeConfigDir, `${configPath}${ext}`);
+        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
+        if (config3 !== null) {
+          if (verbose) {
+            log.success(`Configuration loaded from user config directory: ${fullPath}`);
+          }
+          return config3;
+        }
+      }
+    }
+  }
+  if (name) {
+    const homeConfigDir = resolve3(homedir(), ".config");
+    const homeConfigDotfilePatterns = [`.${name}.config`];
+    if (alias)
+      homeConfigDotfilePatterns.push(`.${alias}.config`);
+    if (verbose)
+      log.info(`Checking user config directory for dotfile configs: ${homeConfigDir}`);
+    for (const configPath of homeConfigDotfilePatterns) {
+      for (const ext of extensions) {
+        const fullPath = resolve3(homeConfigDir, `${configPath}${ext}`);
+        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
+        if (config3 !== null) {
+          if (verbose)
+            log.success(`Configuration loaded from user config directory dotfile: ${fullPath}`);
+          return config3;
+        }
+      }
+    }
+  }
+  if (name) {
+    const homeDir = homedir();
+    const homeRootPatterns = [`.${name}.config`, `.${name}`];
+    if (alias) {
+      homeRootPatterns.push(`.${alias}.config`);
+      homeRootPatterns.push(`.${alias}`);
+    }
+    if (verbose)
+      log.info(`Checking user home directory for dotfile configs: ${homeDir}`);
+    for (const configPath of homeRootPatterns) {
+      for (const ext of extensions) {
+        const fullPath = resolve3(homeDir, `${configPath}${ext}`);
+        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
+        if (config3 !== null) {
+          if (verbose)
+            log.success(`Configuration loaded from user home directory: ${fullPath}`);
+          return config3;
+        }
+      }
+    }
+  }
+  try {
+    const pkgPath = resolve3(baseDir, "package.json");
+    if (existsSync3(pkgPath)) {
+      const pkg = await import(pkgPath);
+      let pkgConfig = pkg[name];
+      if (!pkgConfig && alias) {
+        pkgConfig = pkg[alias];
+        if (pkgConfig && verbose) {
+          log.success(`Using alias "${alias}" configuration from package.json`);
+        }
+      }
+      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
+        try {
+          if (verbose) {
+            log.success(`Configuration loaded from package.json: ${pkgConfig === pkg[name] ? name : alias}`);
+          }
+          return deepMergeWithArrayStrategy(configWithEnvVars, pkgConfig, arrayStrategy);
+        } catch (error) {
+          if (verbose) {
+            log.warn(`Failed to merge package.json config:`, error);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (verbose) {
+      log.warn(`Failed to load package.json:`, error);
+    }
+  }
+  if (verbose) {
+    log.info(`No configuration found for "${name}"${alias ? ` or alias "${alias}"` : ""}, using default configuration with environment variables`);
+  }
+  return configWithEnvVars;
+}
+var defaultConfigDir2 = resolve3(process6.cwd(), "config");
+var defaultGeneratedDir2 = resolve3(process6.cwd(), "src/generated");
+
+// src/config.ts
+var defaultConfig2 = {
+  verbose: true,
+  dialect: "postgres",
+  timestamps: {
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+    defaultOrderColumn: "created_at"
+  },
+  pagination: {
+    defaultPerPage: 25,
+    cursorColumn: "id"
+  },
+  aliasing: {
+    relationColumnAliasFormat: "table_column"
+  },
+  relations: {
+    foreignKeyFormat: "singularParent_id"
+  },
+  transactionDefaults: {
+    retries: 2,
+    isolation: "read committed",
+    sqlStates: ["40001", "40P01"],
+    backoff: {
+      baseMs: 50,
+      factor: 2,
+      maxMs: 2000,
+      jitter: true
+    }
+  },
+  sql: {
+    randomFunction: "RANDOM()",
+    sharedLockSyntax: "FOR SHARE",
+    jsonContainsMode: "operator"
+  },
+  features: {
+    distinctOn: true
+  },
+  debug: {
+    captureText: true
+  },
+  hooks: {},
+  softDeletes: {
+    enabled: false,
+    column: "deleted_at",
+    defaultFilter: true
+  }
+};
+var config2 = await loadConfig3({
+  name: "query-builder",
+  defaultConfig: defaultConfig2
+});
+
+// src/actions/sql.ts
+function sql(dir, table, opts = {}) {
+  const models = loadModels({ modelsDir: dir });
+  const dbSchema = buildDatabaseSchema(models);
+  if (config2.debug)
+    config2.debug.captureText = true;
+  const qb = createQueryBuilder({ schema: dbSchema });
+  const s = qb.selectFrom(table).limit(Number(opts.limit || 10)).toText?.() ?? "";
+  console.log(s || "[query]");
+  return { sql: s, qb, schema: dbSchema };
+}
+// src/actions/unsafe.ts
+async function unsafe(sql2, opts = {}) {
+  const qb = createQueryBuilder();
+  const params = opts.params ? JSON.parse(opts.params) : undefined;
+  const res = await qb.unsafe(sql2, params);
+  console.log(JSON.stringify(res));
+  return res;
+}
+// src/actions/wait-ready.ts
+async function waitReady(opts = {}) {
+  const attempts = Number(opts.attempts || 10);
+  const delayMs = Number(opts.delay || 100);
+  const qb = createQueryBuilder();
+  try {
+    await qb.waitForReady({ attempts, delayMs });
+    console.log("READY");
+    return true;
+  } catch {
+    console.error("NOT READY");
+    throw new Error("Database not ready");
+  }
+}
+// src/client.ts
+var {sql: bunSql2 } = globalThis.Bun;
+function applyWhere(columns, q, expr) {
+  if (!expr)
+    return q;
+  if (Array.isArray(expr)) {
+    const [col, op, val] = expr;
+    switch (op) {
+      case "in":
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} IN ${bunSql2(val)}`;
+      case "not in":
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} NOT IN ${bunSql2(val)}`;
+      case "like":
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} LIKE ${val}`;
+      case "is":
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} IS ${val}`;
+      case "is not":
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} IS NOT ${val}`;
+      case "!=":
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} <> ${val}`;
+      case "<":
+      case ">":
+      case "<=":
+      case ">=":
+      case "=":
+      default:
+        return bunSql2`${q} WHERE ${bunSql2(String(col))} ${op} ${val}`;
+    }
+  }
+  if ("raw" in expr) {
+    return bunSql2`${q} WHERE ${expr.raw}`;
+  }
+  const parts = [];
+  for (const key of Object.keys(expr)) {
+    const value = expr[key];
+    if (Array.isArray(value))
+      parts.push(bunSql2`${bunSql2(key)} IN ${bunSql2(value)}`);
+    else
+      parts.push(bunSql2`${bunSql2(key)} = ${value}`);
+  }
+  if (parts.length === 0)
+    return q;
+  return bunSql2`${q} WHERE ${parts.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc} AND ${p}`)}`;
+}
+function isRetriableTxError(err) {
+  const msg = String(err?.message || "").toLowerCase();
+  return msg.includes("deadlock") || msg.includes("serialization failure") || msg.includes("could not serialize access") || msg.includes("deadlock found when trying to get lock") || msg.includes("lock wait timeout exceeded") || msg.includes("database is locked") || msg.includes("busy");
+}
+function matchesSqlState(err, states) {
+  if (!states || states.length === 0)
+    return false;
+  const code = err && (err.code || err.sqlState || err.sqlstate);
+  if (!code)
+    return false;
+  return states.includes(code);
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function computeBackoffMs(attempt, cfg) {
+  const base = Math.max(1, cfg?.baseMs ?? 50);
+  const factor = Math.max(1, cfg?.factor ?? 2);
+  const max = Math.max(base, cfg?.maxMs ?? 2000);
+  let ms = Math.min(max, base * factor ** Math.max(0, attempt - 1));
+  if (cfg?.jitter) {
+    const jitter = Math.random() * ms * 0.2;
+    ms = ms - jitter / 2;
+  }
+  return Math.floor(ms);
+}
+function createQueryBuilder(state) {
+  const _sql = state?.sql ?? bunSql2;
+  const meta = state?.meta;
+  const schema = state?.schema;
+  function computeSqlText(q) {
+    const prev = config2.debug?.captureText;
+    if (config2.debug)
+      config2.debug.captureText = true;
+    const s = String(q);
+    if (config2.debug)
+      config2.debug.captureText = prev;
+    return s;
+  }
+  function runWithHooks(q, kind, opts) {
+    const text = computeSqlText(q);
+    const hooks = config2.hooks;
+    const startAt = Date.now();
+    let span;
+    try {
+      hooks?.onQueryStart?.({ sql: text, kind });
+      if (hooks?.startSpan)
+        span = hooks.startSpan({ sql: text, kind });
+    } catch {}
+    let finished = false;
+    const finish = (err, rowCount) => {
+      if (finished)
+        return;
+      finished = true;
+      const durationMs = Date.now() - startAt;
+      try {
+        if (err) {
+          hooks?.onQueryError?.({ sql: text, error: err, durationMs, kind });
+        } else {
+          hooks?.onQueryEnd?.({ sql: text, durationMs, rowCount, kind });
+        }
+      } catch {}
+      try {
+        span?.end(err);
+      } catch {}
+    };
+    const execPromise = q.execute();
+    const promises = [execPromise];
+    let timeoutId;
+    if (opts?.timeoutMs && opts.timeoutMs > 0) {
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          try {
+            q.cancel?.();
+          } catch {}
+          const err = new Error(`Query timed out after ${opts.timeoutMs}ms`);
+          err.code = "EBQBTIMEOUT";
+          reject(err);
+        }, opts.timeoutMs);
+      });
+      promises.push(timeoutPromise);
+    }
+    if (opts?.signal) {
+      if (opts.signal.aborted) {
+        try {
+          q.cancel?.();
+        } catch {}
+        const err = new Error("Query aborted");
+        err.code = "EBQBABORT";
+        finish(err);
+        return Promise.reject(err);
+      }
+      const abortHandler = () => {
+        try {
+          q.cancel?.();
+        } catch {}
+      };
+      opts.signal.addEventListener("abort", abortHandler, { once: true });
+      execPromise.finally(() => {
+        opts.signal?.removeEventListener("abort", abortHandler);
+      });
+    }
+    return Promise.race(promises).then((rows) => {
+      clearTimeout(timeoutId);
+      const rc = Array.isArray(rows) ? rows.length : typeof rows === "number" ? rows : undefined;
+      finish(undefined, rc);
+      return rows;
+    }).catch((err) => {
+      clearTimeout(timeoutId);
+      finish(err);
+      throw err;
+    });
+  }
+  function makeExecutableQuery(q, text) {
+    return {
+      toString: () => text ?? computeSqlText(q),
+      execute: () => q.execute(),
+      values: () => q.values(),
+      raw: () => q.raw()
+    };
+  }
+  function makeSelect(table, columns) {
+    let built = columns && columns.length > 0 ? bunSql2`SELECT ${bunSql2(columns)} FROM ${bunSql2(String(table))}` : bunSql2`SELECT * FROM ${bunSql2(String(table))}`;
+    let text = columns && columns.length > 0 ? `SELECT ${columns.join(", ")} FROM ${String(table)}` : `SELECT * FROM ${String(table)}`;
+    const addWhereText = (prefix, clause) => {
+      const hasWhere = /\bWHERE\b/i.test(text);
+      const p = hasWhere ? prefix : "WHERE";
+      text = `${text} ${p} ${clause}`;
+    };
+    const joinedTables = new Set;
+    let timeoutMs;
+    let abortSignal;
+    let includeTrashed = false;
+    let onlyTrashed = false;
+    const base = {
+      distinct() {
+        const rest = String(built).replace(/^SELECT\s+/i, "");
+        built = bunSql2`SELECT DISTINCT ${bunSql2``}${bunSql2(rest)}`;
+        return this;
+      },
+      distinctOn(...columns2) {
+        const match = /^SELECT\s+(\S+)\s+FROM/i.exec(String(built));
+        const body = match ? `${match[1]} FROM` : String(built);
+        built = bunSql2`SELECT DISTINCT ON (${bunSql2(columns2)}) ${bunSql2``}${bunSql2(body)}`;
+        return this;
+      },
+      selectRaw(fragment) {
+        built = bunSql2`${built} , ${fragment}`;
+        return this;
+      },
+      rowNumber(alias = "row_number", partitionBy, orderBy) {
+        const parts = [];
+        if (partitionBy) {
+          const cols = Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+          parts.push(bunSql2`PARTITION BY ${bunSql2(cols)}`);
+        }
+        if (orderBy && orderBy.length) {
+          const ob = orderBy.map(([c, d]) => bunSql2`${bunSql2(c)} ${d === "desc" ? bunSql2`DESC` : bunSql2`ASC`}`);
+          const expr = ob.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc}, ${p}`);
+          parts.push(bunSql2`ORDER BY ${expr}`);
+        }
+        const over = parts.length ? bunSql2`OVER (${bunSql2(parts)})` : bunSql2`OVER ()`;
+        built = bunSql2`${built} , ROW_NUMBER() ${over} AS ${bunSql2(alias)}`;
+        return this;
+      },
+      denseRank(alias = "dense_rank", partitionBy, orderBy) {
+        const cols = Array.isArray(partitionBy) ? partitionBy : partitionBy ? [partitionBy] : [];
+        const parts = [];
+        if (cols.length)
+          parts.push(bunSql2`PARTITION BY ${bunSql2(cols)}`);
+        if (orderBy && orderBy.length) {
+          const ob = orderBy.map(([c, d]) => bunSql2`${bunSql2(c)} ${d === "desc" ? bunSql2`DESC` : bunSql2`ASC`}`);
+          const expr = ob.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc}, ${p}`);
+          parts.push(bunSql2`ORDER BY ${expr}`);
+        }
+        const over = parts.length ? bunSql2`OVER (${bunSql2(parts)})` : bunSql2`OVER ()`;
+        built = bunSql2`${built} , DENSE_RANK() ${over} AS ${bunSql2(alias)}`;
+        return this;
+      },
+      rank(alias = "rank", partitionBy, orderBy) {
+        const cols = Array.isArray(partitionBy) ? partitionBy : partitionBy ? [partitionBy] : [];
+        const parts = [];
+        if (cols.length)
+          parts.push(bunSql2`PARTITION BY ${bunSql2(cols)}`);
+        if (orderBy && orderBy.length) {
+          const ob = orderBy.map(([c, d]) => bunSql2`${bunSql2(c)} ${d === "desc" ? bunSql2`DESC` : bunSql2`ASC`}`);
+          const expr = ob.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc}, ${p}`);
+          parts.push(bunSql2`ORDER BY ${expr}`);
+        }
+        const over = parts.length ? bunSql2`OVER (${bunSql2(parts)})` : bunSql2`OVER ()`;
+        built = bunSql2`${built} , RANK() ${over} AS ${bunSql2(alias)}`;
+        return this;
+      },
+      selectAll() {
+        return this;
+      },
+      addSelect(...columns2) {
+        if (!columns2.length)
+          return this;
+        const body = String(built).replace(/^SELECT\s+/i, "");
+        built = bunSql2`SELECT ${bunSql2(columns2)} , ${bunSql2(body)} `;
+        return this;
+      },
+      with(...relations) {
+        if (!meta || relations.length === 0)
+          return this;
+        const parentTable = String(table);
+        const singularize = (name) => {
+          if (config2.relations.singularizeStrategy === "none")
+            return name;
+          return name.endsWith("s") ? name.slice(0, -1) : name;
+        };
+        const addJoin = (fromTable, relationKey) => {
+          const rels = meta.relations?.[fromTable];
+          const resolveTarget = () => {
+            const pick = (m) => {
+              const modelName = m?.[relationKey];
+              return modelName ? meta.modelToTable[modelName] : undefined;
+            };
+            return pick(rels?.hasOne) || pick(rels?.hasMany) || pick(rels?.belongsTo) || pick(rels?.belongsToMany);
+          };
+          const targetTable = resolveTarget() ?? (meta.modelToTable[relationKey] || meta.tableToModel[relationKey] ? meta.modelToTable[relationKey] ?? relationKey : relationKey);
+          const childTable = String(targetTable);
+          if (!childTable || childTable === fromTable)
+            return fromTable;
+          const isBtm = Boolean(rels?.belongsToMany?.[relationKey]);
+          if (isBtm) {
+            const a = singularize(fromTable);
+            const b = singularize(childTable);
+            const pivot = [a, b].sort().join("_");
+            const fromPk = meta.primaryKeys[fromTable] ?? "id";
+            const childPk = meta.primaryKeys[childTable] ?? "id";
+            const fkA = `${singularize(fromTable)}_id`;
+            const fkB = `${singularize(childTable)}_id`;
+            built = bunSql2`${built} LEFT JOIN ${bunSql2(pivot)} ON ${bunSql2(`${pivot}.${fkA}`)} = ${bunSql2(`${fromTable}.${fromPk}`)} LEFT JOIN ${bunSql2(childTable)} ON ${bunSql2(`${childTable}.${childPk}`)} = ${bunSql2(`${pivot}.${fkB}`)}`;
+            joinedTables.add(pivot);
+            joinedTables.add(childTable);
+            return childTable;
+          }
+          const isBt = Boolean(rels?.belongsTo?.[relationKey]);
+          if (isBt) {
+            const fkInParent = `${singularize(childTable)}_id`;
+            const childPk = meta.primaryKeys[childTable] ?? "id";
+            built = bunSql2`${built} LEFT JOIN ${bunSql2(childTable)} ON ${bunSql2(`${fromTable}.${fkInParent}`)} = ${bunSql2(`${childTable}.${childPk}`)}`;
+            joinedTables.add(childTable);
+            return childTable;
+          }
+          const fkInChild = `${singularize(fromTable)}_id`;
+          const pk = meta.primaryKeys[fromTable] ?? "id";
+          built = bunSql2`${built} LEFT JOIN ${bunSql2(childTable)} ON ${bunSql2(`${childTable}.${fkInChild}`)} = ${bunSql2(`${fromTable}.${pk}`)}`;
+          joinedTables.add(childTable);
+          return childTable;
+        };
+        for (const rel of relations) {
+          const parts = rel.split(".");
+          let from = parentTable;
+          for (const part of parts) {
+            const next = addJoin(from, part) || from;
+            from = next;
+          }
+        }
+        return this;
+      },
+      where(expr, op, value) {
+        if (typeof expr === "string" && op !== undefined) {
+          built = applyWhere({}, built, [expr, op, value]);
+          try {
+            addWhereText("WHERE", `${String(expr)} ${String(op).toUpperCase()} ?`);
+          } catch {}
+          return this;
+        }
+        built = applyWhere({}, built, expr);
+        try {
+          if (Array.isArray(expr)) {
+            const [col, op2] = expr;
+            const opText = String(op2).toUpperCase().replace("NOT IN", "NOT IN").replace("IN", "IN");
+            addWhereText("WHERE", `${String(col)} ${opText} ?`);
+          } else if (expr && typeof expr === "object" && !("raw" in expr)) {
+            const parts = [];
+            for (const k of Object.keys(expr)) {
+              const v = expr[k];
+              parts.push(Array.isArray(v) ? `${k} IN (?)` : `${k} = ?`);
+            }
+            if (parts.length)
+              addWhereText("WHERE", parts.join(" AND "));
+          } else if (expr && typeof expr.raw !== "undefined") {
+            addWhereText("WHERE", "[raw]");
+          }
+        } catch {}
+        return this;
+      },
+      whereNull(column) {
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} IS NULL`;
+        return this;
+      },
+      whereNotNull(column) {
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} IS NOT NULL`;
+        return this;
+      },
+      whereBetween(column, start, end) {
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} BETWEEN ${start} AND ${end}`;
+        return this;
+      },
+      whereExists(subquery) {
+        built = bunSql2`${built} WHERE EXISTS (${subquery.toSQL()})`;
+        return this;
+      },
+      whereJsonContains(column, json) {
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} @> ${bunSql2(JSON.stringify(json))}`;
+        addWhereText("WHERE", `${String(column)} @> ?`);
+        return this;
+      },
+      whereJsonPath(path, op, value) {
+        const dialect = config2.dialect;
+        if (dialect === "postgres") {
+          built = bunSql2`${built} WHERE ${bunSql2(path)} ${op} ${value}`;
+        } else if (dialect === "mysql") {
+          built = bunSql2`${built} WHERE JSON_EXTRACT(${bunSql2(path)}) ${op} ${value}`;
+        } else {
+          built = bunSql2`${built} WHERE json_extract(${bunSql2(path)}) ${op} ${value}`;
+        }
+        return this;
+      },
+      whereLike(column, pattern, caseSensitive = false) {
+        const expr = caseSensitive ? bunSql2`${bunSql2(String(column))} LIKE ${pattern}` : bunSql2`LOWER(${bunSql2(String(column))}) LIKE LOWER(${pattern})`;
+        built = bunSql2`${built} WHERE ${expr}`;
+        addWhereText("WHERE", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        return this;
+      },
+      whereILike(column, pattern) {
+        if (config2.dialect === "postgres") {
+          built = bunSql2`${built} WHERE ${bunSql2(String(column))} ILIKE ${pattern}`;
+          addWhereText("WHERE", `${String(column)} ILIKE ?`);
+        } else {
+          const expr = bunSql2`LOWER(${bunSql2(String(column))}) LIKE LOWER(${pattern})`;
+          built = bunSql2`${built} WHERE ${expr}`;
+          addWhereText("WHERE", `LOWER(${String(column)}) LIKE LOWER(?)`);
+        }
+        return this;
+      },
+      orWhereLike(column, pattern, caseSensitive = false) {
+        const expr = caseSensitive ? bunSql2`${bunSql2(String(column))} LIKE ${pattern}` : bunSql2`LOWER(${bunSql2(String(column))}) LIKE LOWER(${pattern})`;
+        built = bunSql2`${built} OR ${expr}`;
+        addWhereText("OR", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        return this;
+      },
+      orWhereILike(column, pattern) {
+        if (config2.dialect === "postgres") {
+          built = bunSql2`${built} OR ${bunSql2(String(column))} ILIKE ${pattern}`;
+          addWhereText("OR", `${String(column)} ILIKE ?`);
+        } else {
+          const expr = bunSql2`LOWER(${bunSql2(String(column))}) LIKE LOWER(${pattern})`;
+          built = bunSql2`${built} OR ${expr}`;
+          addWhereText("OR", `LOWER(${String(column)}) LIKE LOWER(?)`);
+        }
+        return this;
+      },
+      whereNotLike(column, pattern, caseSensitive = false) {
+        const expr = caseSensitive ? bunSql2`${bunSql2(String(column))} NOT LIKE ${pattern}` : bunSql2`LOWER(${bunSql2(String(column))}) NOT LIKE LOWER(${pattern})`;
+        built = bunSql2`${built} WHERE ${expr}`;
+        addWhereText("WHERE", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} NOT LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        return this;
+      },
+      whereNotILike(column, pattern) {
+        if (config2.dialect === "postgres") {
+          built = bunSql2`${built} WHERE ${bunSql2(String(column))} NOT ILIKE ${pattern}`;
+          addWhereText("WHERE", `${String(column)} NOT ILIKE ?`);
+        } else {
+          const expr = bunSql2`LOWER(${bunSql2(String(column))}) NOT LIKE LOWER(${pattern})`;
+          built = bunSql2`${built} WHERE ${expr}`;
+          addWhereText("WHERE", `LOWER(${String(column)}) NOT LIKE LOWER(?)`);
+        }
+        return this;
+      },
+      orWhereNotLike(column, pattern, caseSensitive = false) {
+        const expr = caseSensitive ? bunSql2`${bunSql2(String(column))} NOT LIKE ${pattern}` : bunSql2`LOWER(${bunSql2(String(column))}) NOT LIKE LOWER(${pattern})`;
+        built = bunSql2`${built} OR ${expr}`;
+        addWhereText("OR", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} NOT LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        return this;
+      },
+      orWhereNotILike(column, pattern) {
+        if (config2.dialect === "postgres") {
+          built = bunSql2`${built} OR ${bunSql2(String(column))} NOT ILIKE ${pattern}`;
+          addWhereText("OR", `${String(column)} NOT ILIKE ?`);
+        } else {
+          const expr = bunSql2`LOWER(${bunSql2(String(column))}) NOT LIKE LOWER(${pattern})`;
+          built = bunSql2`${built} OR ${expr}`;
+          addWhereText("OR", `LOWER(${String(column)}) NOT LIKE LOWER(?)`);
+        }
+        return this;
+      },
+      whereAny(cols, op, value) {
+        if (cols.length === 0)
+          return this;
+        const parts = cols.map((c) => bunSql2`${bunSql2(String(c))} ${op} ${value}`);
+        const expr = parts.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc} OR ${p}`);
+        built = bunSql2`${built} WHERE (${expr})`;
+        return this;
+      },
+      whereAll(cols, op, value) {
+        if (cols.length === 0)
+          return this;
+        const parts = cols.map((c) => bunSql2`${bunSql2(String(c))} ${op} ${value}`);
+        const expr = parts.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc} AND ${p}`);
+        built = bunSql2`${built} WHERE (${expr})`;
+        return this;
+      },
+      whereNone(cols, op, value) {
+        if (cols.length === 0)
+          return this;
+        const parts = cols.map((c) => bunSql2`${bunSql2(String(c))} ${op} ${value}`);
+        const expr = parts.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc} OR ${p}`);
+        built = bunSql2`${built} WHERE NOT (${expr})`;
+        return this;
+      },
+      whereNotBetween(column, start, end) {
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} NOT BETWEEN ${start} AND ${end}`;
+        return this;
+      },
+      whereDate(column, op, date) {
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} ${op} ${bunSql2(String(date))}`;
+        return this;
+      },
+      whereRaw(fragment) {
+        built = bunSql2`${built} WHERE ${fragment}`;
+        return this;
+      },
+      whereColumn(left, op, right) {
+        built = bunSql2`${built} WHERE ${bunSql2(left)} ${op} ${bunSql2(right)}`;
+        return this;
+      },
+      orWhereColumn(left, op, right) {
+        built = bunSql2`${built} OR ${bunSql2(left)} ${op} ${bunSql2(right)}`;
+        return this;
+      },
+      whereIn(column, values) {
+        const v = Array.isArray(values) ? bunSql2(values) : bunSql2`(${values.toSQL()})`;
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} IN ${v}`;
+        return this;
+      },
+      orWhereIn(column, values) {
+        const v = Array.isArray(values) ? bunSql2(values) : bunSql2`(${values.toSQL()})`;
+        built = bunSql2`${built} OR ${bunSql2(String(column))} IN ${v}`;
+        return this;
+      },
+      whereNotIn(column, values) {
+        const v = Array.isArray(values) ? bunSql2(values) : bunSql2`(${values.toSQL()})`;
+        built = bunSql2`${built} WHERE ${bunSql2(String(column))} NOT IN ${v}`;
+        return this;
+      },
+      orWhereNotIn(column, values) {
+        const v = Array.isArray(values) ? bunSql2(values) : bunSql2`(${values.toSQL()})`;
+        built = bunSql2`${built} OR ${bunSql2(String(column))} NOT IN ${v}`;
+        return this;
+      },
+      whereNested(fragment) {
+        built = bunSql2`${built} WHERE (${fragment.toSQL ? fragment.toSQL() : fragment})`;
+        return this;
+      },
+      orWhereNested(fragment) {
+        built = bunSql2`${built} OR (${fragment.toSQL ? fragment.toSQL() : fragment})`;
+        return this;
+      },
+      andWhere(expr, op, value) {
+        if (typeof expr === "string" && op !== undefined) {
+          built = bunSql2`${built} AND ${applyWhere({}, bunSql2``, [expr, op, value])}`;
+          try {
+            addWhereText("AND", `${String(expr)} ${String(op).toUpperCase()} ?`);
+          } catch {}
+          return this;
+        }
+        built = bunSql2`${built} AND ${applyWhere({}, bunSql2``, expr)}`;
+        try {
+          if (Array.isArray(expr)) {
+            const [col, op2] = expr;
+            addWhereText("AND", `${String(col)} ${String(op2).toUpperCase()} ?`);
+          } else if (expr && typeof expr === "object" && !("raw" in expr)) {
+            const parts = [];
+            for (const k of Object.keys(expr)) {
+              const v = expr[k];
+              parts.push(Array.isArray(v) ? `${k} IN (?)` : `${k} = ?`);
+            }
+            if (parts.length)
+              addWhereText("AND", parts.join(" AND "));
+          } else if (expr && typeof expr.raw !== "undefined") {
+            addWhereText("AND", "[raw]");
+          }
+        } catch {}
+        return this;
+      },
+      orWhere(expr, op, value) {
+        if (typeof expr === "string" && op !== undefined) {
+          built = bunSql2`${built} OR ${applyWhere({}, bunSql2``, [expr, op, value])}`;
+          try {
+            addWhereText("OR", `${String(expr)} ${String(op).toUpperCase()} ?`);
+          } catch {}
+          return this;
+        }
+        built = bunSql2`${built} OR ${applyWhere({}, bunSql2``, expr)}`;
+        try {
+          if (Array.isArray(expr)) {
+            const [col, op2] = expr;
+            addWhereText("OR", `${String(col)} ${String(op2).toUpperCase()} ?`);
+          } else if (expr && typeof expr === "object" && !("raw" in expr)) {
+            const parts = [];
+            for (const k of Object.keys(expr)) {
+              const v = expr[k];
+              parts.push(Array.isArray(v) ? `${k} IN (?)` : `${k} = ?`);
+            }
+            if (parts.length)
+              addWhereText("OR", parts.join(" AND "));
+          } else if (expr && typeof expr.raw !== "undefined") {
+            addWhereText("OR", "[raw]");
+          }
+        } catch {}
+        return this;
+      },
+      orderBy(column, direction = "asc") {
+        built = bunSql2`${built} ORDER BY ${bunSql2(String(column))} ${direction === "asc" ? bunSql2`ASC` : bunSql2`DESC`}`;
+        return this;
+      },
+      orderByDesc(column) {
+        built = bunSql2`${built} ORDER BY ${bunSql2(String(column))} DESC`;
+        return this;
+      },
+      inRandomOrder() {
+        const rnd = config2.sql.randomFunction === "RAND()" ? bunSql2`RAND()` : bunSql2`RANDOM()`;
+        built = bunSql2`${built} ORDER BY ${rnd}`;
+        return this;
+      },
+      reorder(column, direction = "asc") {
+        built = bunSql2`${bunSql2(String(built).replace(/ORDER BY[\s\S]*$/i, ""))} ORDER BY ${bunSql2(column)} ${direction === "asc" ? bunSql2`ASC` : bunSql2`DESC`}`;
+        return this;
+      },
+      latest(column) {
+        const col = column ?? config2.timestamps.defaultOrderColumn;
+        built = bunSql2`${built} ORDER BY ${bunSql2(String(col))} DESC`;
+        return this;
+      },
+      oldest(column) {
+        const col = column ?? config2.timestamps.defaultOrderColumn;
+        built = bunSql2`${built} ORDER BY ${bunSql2(String(col))} ASC`;
+        return this;
+      },
+      limit(n) {
+        built = bunSql2`${built} LIMIT ${n}`;
+        return this;
+      },
+      offset(n) {
+        built = bunSql2`${built} OFFSET ${n}`;
+        return this;
+      },
+      join(table2, onLeft, operator, onRight) {
+        built = bunSql2`${built} JOIN ${bunSql2(String(table2))} ON ${bunSql2(String(onLeft))} ${operator} ${bunSql2(String(onRight))}`;
+        joinedTables.add(String(table2));
+        return this;
+      },
+      joinSub(sub, alias, onLeft, operator, onRight) {
+        built = bunSql2`${built} JOIN (${sub.toSQL()}) AS ${bunSql2(alias)} ON ${bunSql2(onLeft)} ${operator} ${bunSql2(onRight)}`;
+        joinedTables.add(alias);
+        return this;
+      },
+      innerJoin(table2, onLeft, operator, onRight) {
+        built = bunSql2`${built} INNER JOIN ${bunSql2(String(table2))} ON ${bunSql2(String(onLeft))} ${operator} ${bunSql2(String(onRight))}`;
+        joinedTables.add(String(table2));
+        return this;
+      },
+      leftJoin(table2, onLeft, operator, onRight) {
+        built = bunSql2`${built} LEFT JOIN ${bunSql2(String(table2))} ON ${bunSql2(String(onLeft))} ${operator} ${bunSql2(String(onRight))}`;
+        joinedTables.add(String(table2));
+        return this;
+      },
+      leftJoinSub(sub, alias, onLeft, operator, onRight) {
+        built = bunSql2`${built} LEFT JOIN (${sub.toSQL()}) AS ${bunSql2(alias)} ON ${bunSql2(onLeft)} ${operator} ${bunSql2(onRight)}`;
+        joinedTables.add(alias);
+        return this;
+      },
+      rightJoin(table2, onLeft, operator, onRight) {
+        built = bunSql2`${built} RIGHT JOIN ${bunSql2(String(table2))} ON ${bunSql2(String(onLeft))} ${operator} ${bunSql2(String(onRight))}`;
+        joinedTables.add(String(table2));
+        return this;
+      },
+      crossJoin(table2) {
+        built = bunSql2`${built} CROSS JOIN ${bunSql2(String(table2))}`;
+        joinedTables.add(String(table2));
+        return this;
+      },
+      crossJoinSub(sub, alias) {
+        built = bunSql2`${built} CROSS JOIN (${sub.toSQL()}) AS ${bunSql2(alias)}`;
+        joinedTables.add(alias);
+        return this;
+      },
+      selectAllRelations() {
+        if (!schema)
+          return this;
+        const parent = String(table);
+        const parentCols = Object.keys(schema[parent]?.columns ?? {});
+        const parts = [];
+        if (parentCols.length > 0)
+          parts.push(bunSql2`${bunSql2(parent)}.*`);
+        for (const jt of joinedTables) {
+          const cols = Object.keys(schema[jt]?.columns ?? {});
+          for (const c of cols) {
+            const alias = config2.aliasing.relationColumnAliasFormat === "camelCase" ? `${jt}_${c}`.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase()) : config2.aliasing.relationColumnAliasFormat === "table.dot.column" ? `${jt}.${c}` : `${jt}_${c}`;
+            parts.push(bunSql2`${bunSql2(`${jt}.${c}`)} AS ${bunSql2(alias)}`);
+          }
+        }
+        if (parts.length > 0) {
+          built = bunSql2`SELECT ${bunSql2(parts)} FROM ${bunSql2(parent)} ${bunSql2``}`;
+        }
+        return this;
+      },
+      groupBy(...cols) {
+        if (cols.length > 0)
+          built = bunSql2`${built} GROUP BY ${bunSql2(cols)}`;
+        return this;
+      },
+      groupByRaw(fragment) {
+        built = bunSql2`${built} GROUP BY ${fragment}`;
+        return this;
+      },
+      having(expr) {
+        built = bunSql2`${built} HAVING ${applyWhere({}, bunSql2``, expr)}`;
+        return this;
+      },
+      havingRaw(fragment) {
+        built = bunSql2`${built} HAVING ${fragment}`;
+        return this;
+      },
+      orderByRaw(fragment) {
+        built = bunSql2`${built} ORDER BY ${fragment}`;
+        return this;
+      },
+      union(other) {
+        built = bunSql2`${built} UNION ${other.toSQL()}`;
+        return this;
+      },
+      unionAll(other) {
+        built = bunSql2`${built} UNION ALL ${other.toSQL()}`;
+        return this;
+      },
+      forPage(page, perPage) {
+        const p = Math.max(1, Math.floor(page));
+        const pp = Math.max(1, Math.floor(perPage));
+        built = bunSql2`${built} LIMIT ${pp} OFFSET ${(p - 1) * pp}`;
+        return this;
+      },
+      toSQL() {
+        return makeExecutableQuery(built, text);
+      },
+      async value(column) {
+        const q = bunSql2`${built} LIMIT 1`;
+        const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
+        const [row] = rows;
+        return row?.[column];
+      },
+      async pluck(column, key) {
+        const rows = await runWithHooks(built, "select", { signal: abortSignal, timeoutMs });
+        if (key) {
+          const out = {};
+          for (const r of rows)
+            out[String(r?.[key])] = r?.[column];
+          return out;
+        }
+        return rows.map((r) => r?.[column]);
+      },
+      async exists() {
+        const q = bunSql2`SELECT EXISTS (${built}) as e`;
+        const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
+        const [row] = rows;
+        return Boolean(row?.e);
+      },
+      async doesntExist() {
+        const e = await this.exists();
+        return !e;
+      },
+      async paginate(perPage, page = 1) {
+        const countQ = bunSql2`SELECT COUNT(*) as c FROM (${built}) as sub`;
+        const cRows = await runWithHooks(countQ, "select", { signal: abortSignal, timeoutMs });
+        const [cRow] = cRows;
+        const total = Number(cRow?.c ?? 0);
+        const lastPage = Math.max(1, Math.ceil(total / perPage));
+        const p = Math.max(1, Math.min(page, lastPage));
+        const offset = (p - 1) * perPage;
+        const data = await runWithHooks(bunSql2`${built} LIMIT ${perPage} OFFSET ${offset}`, "select", { signal: abortSignal, timeoutMs });
+        return { data, meta: { perPage, page: p, total, lastPage } };
+      },
+      async simplePaginate(perPage, page = 1) {
+        const p = Math.max(1, page);
+        const offset = (p - 1) * perPage;
+        const data = await runWithHooks(bunSql2`${built} LIMIT ${perPage + 1} OFFSET ${offset}`, "select", { signal: abortSignal, timeoutMs });
+        const hasMore = data.length > perPage;
+        return { data: hasMore ? data.slice(0, perPage) : data, meta: { perPage, page: p, hasMore } };
+      },
+      async cursorPaginate(perPage, cursor, column = "id", direction = "asc") {
+        let q = built;
+        if (cursor !== undefined && cursor !== null) {
+          if (Array.isArray(column)) {
+            const cols = column.map((c) => bunSql2(String(c)));
+            const comp = direction === "asc" ? bunSql2`>` : bunSql2`<`;
+            const tupleCols = bunSql2`(${bunSql2(cols)})`;
+            const tupleVals = bunSql2`(${bunSql2(cursor)})`;
+            q = bunSql2`${q} WHERE ${tupleCols} ${comp} ${tupleVals}`;
+          } else {
+            q = direction === "asc" ? bunSql2`${q} WHERE ${bunSql2(String(column))} > ${cursor}` : bunSql2`${q} WHERE ${bunSql2(String(column))} < ${cursor}`;
+          }
+        }
+        if (Array.isArray(column)) {
+          const orderParts = column.map((c) => bunSql2`${bunSql2(String(c))} ${direction === "asc" ? bunSql2`ASC` : bunSql2`DESC`}`);
+          const orderExpr = orderParts.reduce((acc, p, i) => i === 0 ? p : bunSql2`${acc}, ${p}`);
+          q = bunSql2`${q} ORDER BY ${orderExpr} LIMIT ${perPage + 1}`;
+        } else {
+          q = bunSql2`${q} ORDER BY ${bunSql2(String(column))} ${direction === "asc" ? bunSql2`ASC` : bunSql2`DESC`} LIMIT ${perPage + 1}`;
+        }
+        const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
+        const next = rows.length > perPage ? Array.isArray(column) ? column.map((c) => rows[perPage]?.[c]) : rows[perPage]?.[column] : null;
+        const data = rows.slice(0, perPage);
+        const prevCursor = data.length ? Array.isArray(column) ? column.map((c) => data[0]?.[c]) : data[0]?.[column] : null;
+        return { data, meta: { perPage, nextCursor: next ?? null, prevCursor } };
+      },
+      async chunk(size, handler) {
+        let page = 1;
+        while (true) {
+          const { data } = await this.paginate(size, page);
+          if (data.length === 0)
+            break;
+          await handler(data);
+          if (data.length < size)
+            break;
+          page += 1;
+        }
+      },
+      async chunkById(size, column = "id", handler) {
+        let cursor;
+        while (true) {
+          const { data, meta: meta2 } = await this.cursorPaginate(size, cursor, column, "asc");
+          if (data.length === 0)
+            break;
+          if (handler)
+            await handler(data);
+          cursor = meta2.nextCursor;
+          if (!cursor)
+            break;
+        }
+      },
+      async eachById(size, column = "id", handler) {
+        await this.chunkById(size, column, async (rows) => {
+          for (const r of rows)
+            await handler?.(r);
+        });
+      },
+      withTimeout(ms) {
+        timeoutMs = Math.max(1, Math.floor(ms));
+        return this;
+      },
+      abort(signal) {
+        abortSignal = signal;
+        return this;
+      },
+      withTrashed() {
+        includeTrashed = true;
+        onlyTrashed = false;
+        return this;
+      },
+      onlyTrashed() {
+        includeTrashed = true;
+        onlyTrashed = true;
+        return this;
+      },
+      scope(name, value) {
+        const tbl = String(table);
+        const scopeMap = meta?.scopes?.[tbl];
+        const fn = scopeMap?.[name];
+        if (fn)
+          return fn(this, value);
+        return this;
+      },
+      when(condition, then, otherwise) {
+        if (condition)
+          return then(this);
+        if (otherwise)
+          return otherwise(this);
+        return this;
+      },
+      tap(fn) {
+        fn(this);
+        return this;
+      },
+      dump() {
+        console.log(String(built));
+        return this;
+      },
+      dd() {
+        console.log(String(built));
+        throw new Error("Dump and Die");
+      },
+      async explain() {
+        const q = bunSql2`EXPLAIN ${built}`;
+        return await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
+      },
+      simple() {
+        return built.simple();
+      },
+      toText() {
+        return text;
+      },
+      async get() {
+        if (config2.softDeletes?.enabled && config2.softDeletes.defaultFilter && !includeTrashed) {
+          const col = config2.softDeletes.column;
+          const tbl = String(table);
+          const hasCol = schema ? Boolean(schema[tbl]?.columns?.[col]) : true;
+          if (hasCol && !/\bdeleted_at\b/i.test(text)) {
+            built = bunSql2`${built} WHERE ${bunSql2(String(col))} IS ${onlyTrashed ? bunSql2`NOT NULL` : bunSql2`NULL`}`;
+            addWhereText("WHERE", `${String(col)} IS ${onlyTrashed ? "NOT " : ""}NULL`);
+          }
+        }
+        return await runWithHooks(built, "select", { signal: abortSignal, timeoutMs });
+      },
+      async executeTakeFirst() {
+        const rows = await runWithHooks(built, "select", { signal: abortSignal, timeoutMs });
+        return Array.isArray(rows) ? rows[0] : rows;
+      },
+      async first() {
+        const rows = await runWithHooks(bunSql2`${built} LIMIT 1`, "select", { signal: abortSignal, timeoutMs });
+        const [row] = rows;
+        return row;
+      },
+      async firstOrFail() {
+        const row = await this.first();
+        if (!row)
+          throw new Error("Record not found");
+        return row;
+      },
+      async find(id) {
+        const pk = meta?.primaryKeys[String(table)] ?? "id";
+        const rows = await runWithHooks(bunSql2`${built} WHERE ${bunSql2(pk)} = ${id} LIMIT 1`, "select", { signal: abortSignal, timeoutMs });
+        const [row] = rows;
+        return row;
+      },
+      async findOrFail(id) {
+        const row = await this.find(id);
+        if (!row)
+          throw new Error("Record not found");
+        return row;
+      },
+      async findMany(ids) {
+        const pk = meta?.primaryKeys[String(table)] ?? "id";
+        const rows = await runWithHooks(bunSql2`${built} WHERE ${bunSql2(String(pk))} IN ${bunSql2(ids)}`, "select", { signal: abortSignal, timeoutMs });
+        return rows;
+      },
+      async* lazy() {
+        let cursor;
+        const pk = meta?.primaryKeys[String(table)] ?? "id";
+        while (true) {
+          const q = cursor == null ? bunSql2`${built} ORDER BY ${bunSql2(String(pk))} ASC LIMIT 100` : bunSql2`${built} WHERE ${bunSql2(String(pk))} > ${cursor} ORDER BY ${bunSql2(String(pk))} ASC LIMIT 100`;
+          const rows = await q.execute();
+          if (rows.length === 0)
+            break;
+          for (const r of rows)
+            yield r;
+          cursor = rows[rows.length - 1]?.[pk];
+          if (cursor == null)
+            break;
+        }
+      },
+      async* lazyById() {
+        const pk = meta?.primaryKeys[String(table)] ?? "id";
+        let cursor;
+        while (true) {
+          const q = cursor == null ? bunSql2`${built} ORDER BY ${bunSql2(String(pk))} ASC LIMIT 100` : bunSql2`${built} WHERE ${bunSql2(String(pk))} > ${cursor} ORDER BY ${bunSql2(String(pk))} ASC LIMIT 100`;
+          const rows = await q.execute();
+          if (rows.length === 0)
+            break;
+          for (const r of rows)
+            yield r;
+          cursor = rows[rows.length - 1]?.[pk];
+          if (cursor == null)
+            break;
+        }
+      },
+      pipe(fn) {
+        return fn(this);
+      },
+      async count() {
+        const q = bunSql2`SELECT COUNT(*) as c FROM (${built}) as sub`;
+        const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
+        const [row] = rows;
+        return Number(row?.c ?? 0);
+      },
+      lockForUpdate() {
+        built = bunSql2`${built} FOR UPDATE`;
+        return this;
+      },
+      sharedLock() {
+        const syntax = config2.sql.sharedLockSyntax === "LOCK IN SHARE MODE" ? bunSql2`LOCK IN SHARE MODE` : bunSql2`FOR SHARE`;
+        built = bunSql2`${built} ${syntax}`;
+        return this;
+      },
+      withCTE(name, sub) {
+        built = bunSql2`WITH ${bunSql2(name)} AS (${sub.toSQL()}) ${built}`;
+        return this;
+      },
+      withRecursive(name, sub) {
+        built = bunSql2`WITH RECURSIVE ${bunSql2(name)} AS (${sub.toSQL()}) ${built}`;
+        return this;
+      },
+      execute() {
+        return runWithHooks(built, "select", { signal: abortSignal, timeoutMs });
+      },
+      values() {
+        return built.values();
+      },
+      toParams() {
+        return built.values?.() ?? [];
+      },
+      raw() {
+        return built.raw();
+      },
+      get rows() {
+        return;
+      },
+      get row() {
+        return;
+      },
+      cancel() {
+        try {
+          built.cancel();
+        } catch {}
+      }
+    };
+    const proxy = new Proxy(base, {
+      get(target, prop, receiver) {
+        const existing = Reflect.get(target, prop, receiver);
+        if (existing !== undefined)
+          return existing;
+        if (typeof prop === "string" && (prop.startsWith("where") || prop.startsWith("orWhere") || prop.startsWith("andWhere"))) {
+          const isOr = prop.startsWith("orWhere");
+          const isAnd = prop.startsWith("andWhere");
+          const raw = prop.replace(/^or?where/i, "").replace(/^andwhere/i, "");
+          if (!raw)
+            return () => receiver;
+          const lowerFirst = raw.charAt(0).toLowerCase() + raw.slice(1);
+          const toSnake = (s) => s.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+          const snake = toSnake(raw);
+          const tbl = String(table);
+          const available = schema ? Object.keys(schema[tbl]?.columns ?? {}) : [];
+          const chosen = [snake, lowerFirst, lowerFirst.toLowerCase()].find((n) => available.includes(n)) ?? snake;
+          return (value) => {
+            const expr = Array.isArray(value) ? bunSql2`${bunSql2(String(chosen))} IN ${bunSql2(value)}` : bunSql2`${bunSql2(String(chosen))} = ${value}`;
+            built = isOr ? bunSql2`${built} OR ${expr}` : isAnd ? bunSql2`${built} AND ${expr}` : bunSql2`${built} WHERE ${expr}`;
+            const clause = Array.isArray(value) ? `${String(chosen)} IN (?)` : `${String(chosen)} = ?`;
+            addWhereText(isOr ? "OR" : isAnd ? "AND" : "WHERE", clause);
+            return receiver;
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+    return proxy;
+  }
+  return {
+    configure(opts) {
+      Object.assign(config2, opts);
+      return this;
+    },
+    id(name) {
+      if (!/^[A-Z_][\w.]*$/i.test(name))
+        throw new Error(`Invalid identifier: ${name}`);
+      return bunSql2(String(name));
+    },
+    ids(...names) {
+      for (const n of names) {
+        if (!/^[A-Z_][\w.]*$/i.test(n))
+          throw new Error(`Invalid identifier: ${n}`);
+      }
+      return bunSql2(names);
+    },
+    select(table, ...columns) {
+      return makeSelect(table, columns);
+    },
+    selectFrom(table) {
+      return makeSelect(table);
+    },
+    selectFromSub(sub, alias) {
+      const q = bunSql2`SELECT * FROM (${sub.toSQL()}) AS ${bunSql2(alias)}`;
+      return {
+        where: (_) => this,
+        andWhere: (_) => this,
+        orWhere: (_) => this,
+        orderBy: () => this,
+        limit: () => this,
+        offset: () => this,
+        toSQL: () => makeExecutableQuery(q),
+        execute: () => runWithHooks(q, "select"),
+        values: () => q.values(),
+        raw: () => q.raw(),
+        cancel: () => {
+          try {
+            q.cancel();
+          } catch {}
+        }
+      };
+    },
+    insertInto(table) {
+      let built = bunSql2`INSERT INTO ${bunSql2(String(table))}`;
+      const api = {
+        values(data) {
+          built = bunSql2`${built} ${bunSql2(data)}`;
+          return api;
+        },
+        returning(...cols) {
+          const q = bunSql2`${built} RETURNING ${bunSql2(cols)}`;
+          const obj = {
+            where: () => obj,
+            andWhere: () => obj,
+            orWhere: () => obj,
+            orderBy: () => obj,
+            limit: () => obj,
+            offset: () => obj,
+            toSQL: () => makeExecutableQuery(q, computeSqlText(q)),
+            execute: () => runWithHooks(q, "insert")
+          };
+          return obj;
+        },
+        toSQL() {
+          return makeExecutableQuery(built, computeSqlText(built));
+        },
+        execute() {
+          return runWithHooks(built, "insert");
+        }
+      };
+      return api;
+    },
+    updateTable(table) {
+      let built = bunSql2`UPDATE ${bunSql2(String(table))}`;
+      return {
+        set(values) {
+          built = bunSql2`${built} SET ${bunSql2(values)}`;
+          return this;
+        },
+        where(expr) {
+          built = applyWhere({}, built, expr);
+          return this;
+        },
+        returning(...cols) {
+          const q = bunSql2`${built} RETURNING ${bunSql2(cols)}`;
+          const obj = {
+            where: () => obj,
+            andWhere: () => obj,
+            orWhere: () => obj,
+            orderBy: () => obj,
+            limit: () => obj,
+            offset: () => obj,
+            toSQL: () => makeExecutableQuery(q, computeSqlText(q)),
+            execute: () => runWithHooks(q, "update")
+          };
+          return obj;
+        },
+        toSQL() {
+          return makeExecutableQuery(built, computeSqlText(built));
+        },
+        execute() {
+          return runWithHooks(built, "update");
+        }
+      };
+    },
+    deleteFrom(table) {
+      let built = bunSql2`DELETE FROM ${bunSql2(String(table))}`;
+      return {
+        where(expr) {
+          built = applyWhere({}, built, expr);
+          return this;
+        },
+        returning(...cols) {
+          const q = bunSql2`${built} RETURNING ${bunSql2(cols)}`;
+          const obj = {
+            where: () => obj,
+            andWhere: () => obj,
+            orWhere: () => obj,
+            orderBy: () => obj,
+            limit: () => obj,
+            offset: () => obj,
+            toSQL: () => makeExecutableQuery(q, computeSqlText(q)),
+            execute: () => runWithHooks(q, "delete")
+          };
+          return obj;
+        },
+        toSQL() {
+          return makeExecutableQuery(built, computeSqlText(built));
+        },
+        execute() {
+          return runWithHooks(built, "delete");
+        }
+      };
+    },
+    sql: bunSql2,
+    raw(strings, ...values) {
+      return bunSql2(strings, ...values);
+    },
+    simple(strings, ...values) {
+      return bunSql2(strings, ...values).simple();
+    },
+    async advisoryLock(key) {
+      if (config2.dialect !== "postgres")
+        return;
+      const s = String(key);
+      let hash = 7;
+      for (let i = 0;i < s.length; i++)
+        hash = hash * 31 + s.charCodeAt(i) | 0;
+      const k = typeof key === "number" ? key : Math.abs(hash);
+      const q = bunSql2`SELECT pg_advisory_lock(${k})`;
+      await runWithHooks(q, "raw");
+    },
+    async tryAdvisoryLock(key) {
+      if (config2.dialect !== "postgres")
+        return false;
+      const s = String(key);
+      let hash = 7;
+      for (let i = 0;i < s.length; i++)
+        hash = hash * 31 + s.charCodeAt(i) | 0;
+      const k = typeof key === "number" ? key : Math.abs(hash);
+      const q = bunSql2`SELECT pg_try_advisory_lock(${k}) as ok`;
+      const rows = await runWithHooks(q, "raw");
+      return Boolean(rows?.[0]?.ok);
+    },
+    unsafe(query, params) {
+      return bunSql2.unsafe(query, params);
+    },
+    file(path, params) {
+      return bunSql2.file(path, params);
+    },
+    async reserve() {
+      const reserved = await bunSql2.reserve();
+      const qb = createQueryBuilder({ sql: reserved, meta, schema });
+      qb.release = () => reserved.release();
+      return qb;
+    },
+    async close(opts) {
+      await bunSql2.close(opts);
+    },
+    async listen(channel, handler) {
+      if (handler) {}
+    },
+    async unlisten(_channel) {},
+    async notify(_channel, _payload) {},
+    async copyTo(_queryOrTable, _options) {
+      throw new Error("COPY TO is not yet supported by Bun.sql; placeholder");
+    },
+    async copyFrom(_queryOrTable, _source, _options) {
+      throw new Error("COPY FROM is not yet supported by Bun.sql; placeholder");
+    },
+    async ping() {
+      try {
+        const q = bunSql2`SELECT 1`;
+        await runWithHooks(q, "select");
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async waitForReady(opts) {
+      const attempts = Math.max(1, opts?.attempts ?? 10);
+      const delay = Math.max(10, opts?.delayMs ?? 100);
+      for (let i = 0;i < attempts; i++) {
+        if (await this.ping())
+          return;
+        await new Promise((resolve4) => setTimeout(resolve4, delay));
+      }
+      throw new Error("Database not ready after waiting");
+    },
+    async transaction(fn, options) {
+      const defaults = state?.txDefaults;
+      const opts = { ...defaults, ...options };
+      const runWith = async (attempt2) => {
+        opts.logger?.({ type: "start", attempt: attempt2 });
+        const start = Date.now();
+        return await bunSql2.begin(async (tx) => {
+          const qb = createQueryBuilder({ sql: tx, meta, schema });
+          if (opts?.isolation) {
+            const level = opts.isolation;
+            const lvl = level === "read committed" ? bunSql2`READ COMMITTED` : level === "repeatable read" ? bunSql2`REPEATABLE READ` : bunSql2`SERIALIZABLE`;
+            await tx`${bunSql2`SET TRANSACTION ISOLATION LEVEL`} ${lvl}`.execute();
+          }
+          if (opts?.readOnly) {
+            try {
+              await tx`${bunSql2`SET TRANSACTION READ ONLY`}`.execute();
+            } catch {}
+          }
+          const res = await fn(qb);
+          const durationMs = Date.now() - start;
+          opts.logger?.({ type: "commit", attempt: attempt2, durationMs });
+          return res;
+        });
+      };
+      const retries = Math.max(0, opts?.retries ?? 0);
+      let attempt = 0;
+      for (;; ) {
+        try {
+          const out = await runWith(attempt + 1);
+          opts?.afterCommit?.();
+          return out;
+        } catch (err) {
+          const retriable = isRetriableTxError(err) || matchesSqlState(err, opts.sqlStates);
+          if (attempt < retries && retriable) {
+            attempt++;
+            opts?.onRetry?.(attempt, err);
+            const delay = computeBackoffMs(attempt, opts.backoff);
+            if (delay > 0)
+              await sleep(delay);
+            continue;
+          }
+          try {
+            opts.onRollback?.(err);
+          } catch {}
+          try {
+            opts.afterRollback?.();
+          } catch {}
+          throw err;
+        }
+      }
+    },
+    async savepoint(fn) {
+      const s = _sql;
+      if (!s || typeof s.savepoint !== "function")
+        throw new Error("savepoint() must be called inside a transaction");
+      return await s.savepoint(async (sp) => {
+        const qb = createQueryBuilder({ sql: sp, meta, schema });
+        return await fn(qb);
+      });
+    },
+    async beginDistributed(name, fn) {
+      const res = await bunSql2.beginDistributed(name, async (tx) => {
+        const qb = createQueryBuilder({ sql: tx, meta, schema });
+        return await fn(qb);
+      });
+      return res;
+    },
+    async commitDistributed(name) {
+      await bunSql2.commitDistributed(name);
+    },
+    async rollbackDistributed(name) {
+      await bunSql2.rollbackDistributed(name);
+    },
+    setTransactionDefaults(defaults) {
+      state = { ...state, txDefaults: { ...state?.txDefaults, ...defaults } };
+    },
+    transactional(fn, options) {
+      return (...args) => {
+        return this.transaction((tx) => fn(tx, ...args), options);
+      };
+    },
+    async insertOrIgnore(table, values) {
+      const built = bunSql2`INSERT INTO ${bunSql2(String(table))} ${bunSql2(values)} ON CONFLICT DO NOTHING`;
+      return built.execute();
+    },
+    async insertGetId(table, values, idColumn = "id") {
+      const q = bunSql2`INSERT INTO ${bunSql2(String(table))} ${bunSql2(values)} RETURNING ${bunSql2(String(idColumn))} as id`;
+      const [row] = await q.execute();
+      return row?.id;
+    },
+    async updateOrInsert(table, match, values) {
+      const whereParts = Object.keys(match).map((k) => bunSql2`${bunSql2(String(k))} = ${bunSql2(match[k])}`);
+      const existsQ = bunSql2`SELECT 1 FROM ${bunSql2(String(table))} WHERE ${bunSql2(whereParts)} LIMIT 1`;
+      const existsRows = await existsQ.execute();
+      if (existsRows.length) {
+        const upd = bunSql2`UPDATE ${bunSql2(String(table))} SET ${bunSql2(values)} WHERE ${bunSql2(whereParts)}`;
+        await upd.execute();
+        return true;
+      } else {
+        const ins = bunSql2`INSERT INTO ${bunSql2(String(table))} ${bunSql2({ ...match, ...values })}`;
+        await ins.execute();
+        return true;
+      }
+    },
+    async upsert(table, rows, conflictColumns, mergeColumns) {
+      const targetCols = conflictColumns.map((c) => String(c));
+      const setCols = (mergeColumns ?? []).map((c) => String(c));
+      const built = bunSql2`INSERT INTO ${bunSql2(String(table))} ${bunSql2(rows)} ON CONFLICT (${bunSql2(targetCols)}) DO UPDATE SET ${bunSql2(setCols.reduce((acc, c) => ({ ...acc, [c]: bunSql2(`EXCLUDED.${c}`) }), {}))}`;
+      return built.execute();
+    },
+    async save(table, values) {
+      const pk = meta?.primaryKeys[String(table)] ?? "id";
+      const id = values[pk];
+      if (id != null) {
+        await this.updateTable(table).set(values).where({ [pk]: id }).execute();
+        const row = await this.selectFrom(table).find(id);
+        if (!row)
+          throw new Error("save() failed to retrieve updated row");
+        return row;
+      }
+      return await this.create(table, values);
+    },
+    async remove(table, id) {
+      return await this.deleteFrom(table).where({ id }).execute();
+    },
+    async find(table, id) {
+      return await this.selectFrom(table).find(id);
+    },
+    async findOrFail(table, id) {
+      return await this.selectFrom(table).findOrFail(id);
+    },
+    async findMany(table, ids) {
+      return await this.selectFrom(table).findMany(ids);
+    },
+    async latest(table, column) {
+      return await this.selectFrom(table).latest(column).first();
+    },
+    async oldest(table, column) {
+      return await this.selectFrom(table).oldest(column).first();
+    },
+    skip(table, count) {
+      return this.selectFrom(table).offset(count);
+    },
+    async rawQuery(query) {
+      const start = Date.now();
+      try {
+        config2.hooks?.onQueryStart?.({ sql: query, kind: "raw" });
+        const res = await bunSql2.unsafe(query);
+        config2.hooks?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
+        return res;
+      } catch (err) {
+        config2.hooks?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
+        throw err;
+      }
+    },
+    async create(table, values) {
+      const pk = meta?.primaryKeys[String(table)] ?? "id";
+      const id = await this.insertGetId(table, values, pk);
+      const row = await this.selectFrom(table).find(id);
+      if (!row)
+        throw new Error("create() failed to retrieve inserted row");
+      return row;
+    },
+    async createMany(table, rows) {
+      await this.insertInto(table).values(rows).execute();
+    },
+    async firstOrCreate(table, match, defaults) {
+      const existing = await this.selectFrom(table).where(match).first();
+      if (existing)
+        return existing;
+      return await this.create(table, { ...match, ...defaults });
+    },
+    async updateOrCreate(table, match, values) {
+      const existing = await this.selectFrom(table).where(match).first();
+      if (existing) {
+        await this.updateTable(table).set(values).where(match).execute();
+        const pk = meta?.primaryKeys[String(table)] ?? "id";
+        const id = existing[pk];
+        const refreshed = id != null ? await this.selectFrom(table).find(id) : await this.selectFrom(table).where(match).first();
+        if (!refreshed)
+          throw new Error("updateOrCreate() failed to retrieve updated row");
+        return refreshed;
+      }
+      return await this.create(table, { ...match, ...values });
+    },
+    async count(table, column) {
+      const col = column ? bunSql2(String(column)) : bunSql2`*`;
+      const q = bunSql2`SELECT COUNT(${col}) as c FROM ${bunSql2(String(table))}`;
+      const [row] = await q.execute();
+      return Number(row?.c ?? 0);
+    },
+    async sum(table, column) {
+      const q = bunSql2`SELECT SUM(${bunSql2(String(column))}) as s FROM ${bunSql2(String(table))}`;
+      const [row] = await q.execute();
+      return Number(row?.s ?? 0);
+    },
+    async avg(table, column) {
+      const q = bunSql2`SELECT AVG(${bunSql2(String(column))}) as a FROM ${bunSql2(String(table))}`;
+      const [row] = await q.execute();
+      return Number(row?.a ?? 0);
+    },
+    async min(table, column) {
+      const q = bunSql2`SELECT MIN(${bunSql2(String(column))}) as m FROM ${bunSql2(String(table))}`;
+      const [row] = await q.execute();
+      return row?.m;
+    },
+    async max(table, column) {
+      const q = bunSql2`SELECT MAX(${bunSql2(String(column))}) as m FROM ${bunSql2(String(table))}`;
+      const [row] = await q.execute();
+      return row?.m;
+    }
+  };
+}
+// src/factory.ts
+function buildDatabaseSchema(models) {
+  const schema = {};
+  for (const modelName of Object.keys(models)) {
+    const m = models[modelName];
+    const table = m.table || `${String(m.name).toLowerCase()}s`;
+    const attrs = m.attributes ?? {};
+    const columns = {};
+    for (const key of Object.keys(attrs))
+      columns[key] = undefined;
+    schema[table] = {
+      columns,
+      primaryKey: m.primaryKey ?? "id"
+    };
+  }
+  return schema;
+}
+// src/loader.ts
+import { readdirSync as readdirSync3, statSync } from "fs";
+import { basename, extname } from "path";
+import process7 from "process";
+async function loadModels(options) {
+  const cwd = options.cwd ?? process7.cwd();
+  const dir = options.modelsDir.startsWith("/") ? options.modelsDir : `${cwd}/${options.modelsDir}`;
+  const result = {};
+  const entries = readdirSync3(dir);
+  for (const entry of entries) {
+    const full = `${dir}/${entry}`;
+    const st = statSync(full);
+    if (st.isDirectory())
+      continue;
+    const ext = extname(full);
+    if (![".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"].includes(ext))
+      continue;
+    const mod = await import(full);
+    const def = mod.default ?? mod;
+    const fileName = basename(entry, ext);
+    const name = def.name ?? fileName;
+    result[name] = {
+      ...def,
+      name
+    };
+  }
+  return result;
+}
+// src/meta.ts
+function buildSchemaMeta(models) {
+  const modelToTable = {};
+  const tableToModel = {};
+  const primaryKeys = {};
+  const relations = {};
+  const scopesByTable = {};
+  for (const name of Object.keys(models)) {
+    const m = models[name];
+    const table = m.table || `${String(m.name).toLowerCase()}s`;
+    modelToTable[name] = table;
+    tableToModel[table] = name;
+    primaryKeys[table] = m.primaryKey ?? "id";
+    const toRecord = (v) => {
+      if (!v)
+        return {};
+      if (Array.isArray(v)) {
+        const rec = {};
+        for (const relName of v)
+          rec[relName] = relName;
+        return rec;
+      }
+      return v;
+    };
+    relations[table] = {
+      hasOne: toRecord(m.hasOne),
+      hasMany: toRecord(m.hasMany),
+      belongsTo: toRecord(m.belongsTo),
+      belongsToMany: toRecord(m.belongsToMany)
+    };
+    if (m.scopes && typeof m.scopes === "object") {
+      scopesByTable[table] = {};
+      for (const key of Object.keys(m.scopes)) {
+        const fn = m.scopes[key];
+        if (typeof fn === "function")
+          scopesByTable[table][key] = fn;
+      }
+    }
+  }
+  return { modelToTable, tableToModel, primaryKeys, relations, scopes: scopesByTable };
+}
+// src/migrations.ts
+function guessTypeFromName(columnName) {
+  if (columnName.endsWith("_id"))
+    return "bigint";
+  if (columnName.endsWith("_at"))
+    return "datetime";
+  if (columnName.startsWith("is_") || columnName.startsWith("has_"))
+    return "boolean";
+  return;
+}
+function normalizeDefaultValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || value instanceof Date) {
+    return value;
+  }
+  return;
+}
+function buildMigrationPlan(models, options) {
+  const meta = buildSchemaMeta(models);
+  const tables = [];
+  for (const modelName of Object.keys(models)) {
+    const model = models[modelName];
+    const table = model.table || `${String(model.name).toLowerCase()}s`;
+    const primaryKey = model.primaryKey ?? "id";
+    const attrs = model.attributes ?? {};
+    const columns = [];
+    const indexes = [];
+    for (const attrName of Object.keys(attrs)) {
+      const attr = attrs[attrName];
+      const isNullable = true;
+      let inferred = guessTypeFromName(attrName);
+      if (!inferred) {
+        const dv = normalizeDefaultValue(attr.default);
+        if (typeof dv === "string")
+          inferred = dv.length > 255 ? "text" : "string";
+        else if (typeof dv === "number")
+          inferred = Number.isInteger(dv) ? "integer" : "float";
+        else if (typeof dv === "boolean")
+          inferred = "boolean";
+        else if (typeof dv === "bigint")
+          inferred = "bigint";
+        else if (dv instanceof Date)
+          inferred = "datetime";
+      }
+      const isPk = attrName === primaryKey;
+      if (!inferred) {
+        inferred = isPk ? "bigint" : "string";
+      }
+      const col = {
+        name: attrName,
+        type: inferred,
+        isPrimaryKey: isPk,
+        isUnique: Boolean(attr.unique),
+        isNullable,
+        hasDefault: typeof attr.default !== "undefined",
+        defaultValue: normalizeDefaultValue(attr.default)
+      };
+      if (attrName.endsWith("_id")) {
+        const base = attrName.replace(/_id$/, "");
+        const maybeModel = base.charAt(0).toUpperCase() + base.slice(1);
+        const refTable = meta.modelToTable[maybeModel];
+        if (refTable) {
+          const refPk = meta.primaryKeys[refTable] ?? "id";
+          col.references = { table: refTable, column: refPk };
+        }
+      }
+      columns.push(col);
+    }
+    for (const idx of model.indexes ?? []) {
+      indexes.push({ name: idx.name, columns: idx.columns, type: "index" });
+    }
+    for (const c of columns) {
+      if (c.isUnique && !c.isPrimaryKey)
+        indexes.push({ name: `${table}_${c.name}_unique`, columns: [c.name], type: "unique" });
+    }
+    tables.push({ table, columns, indexes });
+  }
+  return { dialect: options.dialect, tables };
+}
+function generateSql(plan) {
+  const statements = [];
+  const q = (id) => plan.dialect === "mysql" ? `\`${id}\`` : `"${id}"`;
+  const columnSql = (c) => {
+    const typeSql = (() => {
+      if (plan.dialect === "postgres" && c.isPrimaryKey) {
+        switch (c.type) {
+          case "integer":
+            return "SERIAL";
+          case "bigint":
+            return "BIGSERIAL";
+          default:
+            break;
+        }
+      }
+      switch (c.type) {
+        case "string":
+          return plan.dialect === "mysql" ? "varchar(255)" : "varchar(255)";
+        case "text":
+          return "text";
+        case "boolean":
+          return plan.dialect === "mysql" ? "tinyint(1)" : "boolean";
+        case "integer":
+          return plan.dialect === "sqlite" ? "integer" : "integer";
+        case "bigint":
+          return "bigint";
+        case "float":
+          return "real";
+        case "double":
+          return "double precision";
+        case "decimal":
+          return "decimal(10,2)";
+        case "date":
+          return "date";
+        case "datetime":
+          return plan.dialect === "mysql" ? "datetime" : "timestamp";
+        case "json":
+          return plan.dialect === "mysql" ? "json" : plan.dialect === "postgres" ? "jsonb" : "text";
+        default:
+          return "text";
+      }
+    })();
+    const parts = [q(c.name), typeSql];
+    if (c.isPrimaryKey)
+      parts.push("primary key");
+    if (!c.isNullable && !c.isPrimaryKey)
+      parts.push("not null");
+    if (c.hasDefault) {
+      const dv = c.defaultValue;
+      if (typeof dv === "string")
+        parts.push(`default '${dv.replace(/'/g, "''")}'`);
+      else if (typeof dv === "number" || typeof dv === "bigint")
+        parts.push(`default ${dv}`);
+      else if (typeof dv === "boolean")
+        parts.push(`default ${dv ? 1 : 0}`);
+      else if (dv instanceof Date)
+        parts.push(`default '${dv.toISOString()}'`);
+    }
+    return parts.join(" ");
+  };
+  for (const t of plan.tables) {
+    statements.push(`CREATE TABLE ${q(t.table)} (
+  ${t.columns.map((c) => columnSql(c)).join(`,
+  `)}
+);`);
+  }
+  for (const t of plan.tables) {
+    for (const c of t.columns) {
+      if (c.references) {
+        const fkName = `${t.table}_${c.name}_fk`;
+        statements.push(`ALTER TABLE ${q(t.table)} ADD CONSTRAINT ${q(fkName)} FOREIGN KEY (${q(c.name)}) REFERENCES ${q(c.references.table)}(${q(c.references.column)});`);
+      }
+    }
+  }
+  for (const t of plan.tables) {
+    for (const idx of t.indexes) {
+      const kind = idx.type === "unique" ? "UNIQUE " : "";
+      const idxName = `${t.table}_${idx.name}`;
+      statements.push(`CREATE ${kind}INDEX ${q(idxName)} ON ${q(t.table)} (${idx.columns.map((c) => q(c)).join(", ")});`);
+    }
+  }
+  return statements;
+}
+function generateSqlString(plan) {
+  return generateSql(plan).join(`
+`);
+}
+function generateDiffSqlString(previous, next) {
+  return generateDiffSql(previous, next).join(`
+`);
+}
+function hashMigrationPlan(plan) {
+  const crypto = __require("crypto");
+  function canonicalize(value) {
+    if (value == null || typeof value !== "object" || value instanceof Date)
+      return value;
+    if (Array.isArray(value))
+      return value.map((v) => canonicalize(v));
+    const out = {};
+    for (const key of Object.keys(value).sort())
+      out[key] = canonicalize(value[key]);
+    return out;
+  }
+  const canon = JSON.stringify(canonicalize(plan));
+  return crypto.createHash("sha256").update(canon).digest("hex");
+}
+function mapTablesByName(tables) {
+  const map = {};
+  for (const t of tables)
+    map[t.table] = t;
+  return map;
+}
+function mapColumnsByName(columns) {
+  const map = {};
+  for (const c of columns)
+    map[c.name] = c;
+  return map;
+}
+function mapIndexesByKey(indexes) {
+  const map = {};
+  for (const i of indexes) {
+    const key = `${i.type}:${i.name}:${i.columns.join(",")}`;
+    map[key] = i;
+  }
+  return map;
+}
+function generateDiffSql(previous, next) {
+  if (!previous || previous.dialect !== next.dialect)
+    return generateSql(next);
+  const chunks = [];
+  const q = (id) => next.dialect === "mysql" ? `\`${id}\`` : `"${id}"`;
+  const prevTables = mapTablesByName(previous.tables);
+  const nextTables = mapTablesByName(next.tables);
+  for (const tableName of Object.keys(nextTables)) {
+    if (!prevTables[tableName]) {
+      const t = nextTables[tableName];
+      chunks.push(`CREATE TABLE ${q(t.table)} (
+  ${t.columns.map((c) => {
+        const tmp = c;
+        const typeSql = (() => {
+          switch (tmp.type) {
+            case "string":
+              return next.dialect === "mysql" ? "varchar(255)" : "varchar(255)";
+            case "text":
+              return "text";
+            case "boolean":
+              return next.dialect === "mysql" ? "tinyint(1)" : "boolean";
+            case "integer":
+              return next.dialect === "sqlite" ? "integer" : "integer";
+            case "bigint":
+              return "bigint";
+            case "float":
+              return "real";
+            case "double":
+              return "double precision";
+            case "decimal":
+              return "decimal(10,2)";
+            case "date":
+              return "date";
+            case "datetime":
+              return next.dialect === "mysql" ? "datetime" : "timestamp";
+            case "json":
+              return next.dialect === "mysql" ? "json" : next.dialect === "postgres" ? "jsonb" : "text";
+            default:
+              return "text";
+          }
+        })();
+        const parts = [q(tmp.name), typeSql];
+        if (tmp.isPrimaryKey)
+          parts.push("primary key");
+        if (!tmp.isNullable && !tmp.isPrimaryKey)
+          parts.push("not null");
+        if (tmp.hasDefault) {
+          const dv = tmp.defaultValue;
+          if (typeof dv === "string")
+            parts.push(`default '${dv.replace(/'/g, "''")}'`);
+          else if (typeof dv === "number" || typeof dv === "bigint")
+            parts.push(`default ${dv}`);
+          else if (typeof dv === "boolean")
+            parts.push(`default ${dv ? 1 : 0}`);
+          else if (dv instanceof Date)
+            parts.push(`default '${dv.toISOString()}'`);
+        }
+        return parts.join(" ");
+      }).join(`,
+  `)}
+);`);
+    }
+  }
+  for (const tableName of Object.keys(nextTables)) {
+    if (!prevTables[tableName]) {
+      const t = nextTables[tableName];
+      for (const c of t.columns) {
+        if (c.references) {
+          const fkName = `${t.table}_${c.name}_fk`;
+          chunks.push(`ALTER TABLE ${q(t.table)} ADD CONSTRAINT ${q(fkName)} FOREIGN KEY (${q(c.name)}) REFERENCES ${q(c.references.table)}(${q(c.references.column)});`);
+        }
+      }
+    }
+  }
+  for (const tableName of Object.keys(nextTables)) {
+    if (!prevTables[tableName]) {
+      const t = nextTables[tableName];
+      for (const idx of t.indexes) {
+        const kind = idx.type === "unique" ? "UNIQUE " : "";
+        const idxName = `${t.table}_${idx.name}`;
+        chunks.push(`CREATE ${kind}INDEX ${q(idxName)} ON ${q(t.table)} (${idx.columns.map((c) => q(c)).join(", ")});`);
+      }
+    }
+  }
+  for (const tableName of Object.keys(nextTables)) {
+    const prev = prevTables[tableName];
+    const curr = nextTables[tableName];
+    if (!prev)
+      continue;
+    const prevCols = mapColumnsByName(prev.columns);
+    const currCols = mapColumnsByName(curr.columns);
+    for (const colName of Object.keys(currCols)) {
+      if (!prevCols[colName]) {
+        const c = currCols[colName];
+        const typeSql = (() => {
+          switch (c.type) {
+            case "string":
+              return next.dialect === "mysql" ? "varchar(255)" : "varchar(255)";
+            case "text":
+              return "text";
+            case "boolean":
+              return next.dialect === "mysql" ? "tinyint(1)" : "boolean";
+            case "integer":
+              return next.dialect === "sqlite" ? "integer" : "integer";
+            case "bigint":
+              return "bigint";
+            case "float":
+              return "real";
+            case "double":
+              return "double precision";
+            case "decimal":
+              return "decimal(10,2)";
+            case "date":
+              return "date";
+            case "datetime":
+              return next.dialect === "mysql" ? "datetime" : "timestamp";
+            case "json":
+              return next.dialect === "mysql" ? "json" : next.dialect === "postgres" ? "jsonb" : "text";
+            default:
+              return "text";
+          }
+        })();
+        const parts = [q(c.name), typeSql];
+        if (!c.isNullable && !c.isPrimaryKey)
+          parts.push("not null");
+        if (c.hasDefault) {
+          const dv = c.defaultValue;
+          if (typeof dv === "string")
+            parts.push(`default '${dv.replace(/'/g, "''")}'`);
+          else if (typeof dv === "number" || typeof dv === "bigint")
+            parts.push(`default ${dv}`);
+          else if (typeof dv === "boolean")
+            parts.push(`default ${dv ? 1 : 0}`);
+          else if (dv instanceof Date)
+            parts.push(`default '${dv.toISOString()}'`);
+        }
+        chunks.push(`ALTER TABLE ${q(curr.table)} ADD COLUMN ${parts.join(" ")};`);
+        if (c.references) {
+          const fkName = `${curr.table}_${c.name}_fk`;
+          chunks.push(`ALTER TABLE ${q(curr.table)} ADD CONSTRAINT ${q(fkName)} FOREIGN KEY (${q(c.name)}) REFERENCES ${q(c.references.table)}(${q(c.references.column)});`);
+        }
+      }
+    }
+    const prevIdx = mapIndexesByKey(prev.indexes);
+    const currIdx = mapIndexesByKey(curr.indexes);
+    for (const key of Object.keys(currIdx)) {
+      if (!prevIdx[key]) {
+        const idx = currIdx[key];
+        const kind = idx.type === "unique" ? "UNIQUE " : "";
+        const idxName = `${curr.table}_${idx.name}`;
+        chunks.push(`CREATE ${kind}INDEX ${q(idxName)} ON ${q(curr.table)} (${idx.columns.map((c) => q(c)).join(", ")});`);
+      }
+    }
+  }
+  if (chunks.length === 0)
+    return ["-- No changes detected"];
+  return chunks;
+}
+// src/schema.ts
+function defineModel(model) {
+  return model;
+}
+function defineModels(models) {
+  return models;
+}
+export {
+  waitReady,
+  unsafe,
+  sql,
+  ping,
+  loadModels,
+  introspect,
+  hashMigrationPlan,
+  generateSqlString,
+  generateSql,
+  generateMigration,
+  generateDiffSqlString,
+  generateDiffSql,
+  file,
+  explain,
+  executeMigration,
+  defineModels,
+  defineModel,
+  defaultConfig2 as defaultConfig,
+  createQueryBuilder,
+  config2 as config,
+  buildSchemaMeta,
+  buildMigrationPlan,
+  buildDatabaseSchema
+};