bun-query-builder 0.2.25 → 0.2.27

package/dist/src/index.js

@@ -3048,25 +3048,27 @@ var init_dynamodb = __esm(() => {
 
 // ../../node_modules/bunfig/dist/index.js
 import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+import process2 from "process";
 import { existsSync as existsSync13, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname4, resolve as resolve12 } from "path";
 import process20 from "process";
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname3, resolve as resolve7 } from "path";
 import process12 from "process";
 import { join as join3, relative as relative2, resolve as resolve4 } from "path";
 import process7 from "process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync32, 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, relative, resolve as resolve2 } from "path";
-import process2 from "process";
+import process22 from "process";
 import { existsSync as existsSync22, mkdirSync, readdirSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
+import { dirname, resolve as resolve5 } from "path";
 import process3 from "process";
 import { Buffer as Buffer2 } from "buffer";
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
@@ -3090,7 +3092,7 @@ import process10 from "process";
 import process9 from "process";
 import process8 from "process";
 import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve52 } from "path";
 import { existsSync as existsSync7 } from "fs";
 import { existsSync as existsSync9, readdirSync as readdirSync5 } from "fs";
 import { extname, resolve as resolve8 } from "path";
@@ -3350,6 +3352,34 @@ class PerformanceMonitor {
     return this.metrics.filter((m) => m.duration > threshold);
   }
 }
+function getConfigNamePatterns(options = {}) {
+  const { name = "", alias } = options;
+  const patterns = ["config", ".config"];
+  if (name)
+    patterns.push(name, `.${name}.config`, `${name}.config`, `.${name}`);
+  const aliases = alias === undefined ? [] : Array.isArray(alias) ? alias : [alias];
+  for (const alternative of aliases) {
+    if (!alternative)
+      continue;
+    patterns.push(alternative, `.${alternative}.config`, `${alternative}.config`, `.${alternative}`);
+    if (name)
+      patterns.push(`${name}.${alternative}.config`, `.${name}.${alternative}.config`);
+  }
+  return Array.from(new Set(patterns.filter(Boolean)));
+}
+function getConfigPaths(options) {
+  const patterns = getConfigNamePatterns(options);
+  return patterns.flatMap((pattern) => CONFIG_FILE_EXTENSIONS.map((extension) => resolve(options.directory, `${pattern}${extension}`)));
+}
+function getLocalConfigDirectories(options = {}) {
+  const cwd = resolve(options.cwd || process2.cwd());
+  return Array.from(new Set([
+    cwd,
+    resolve(cwd, "config"),
+    resolve(cwd, ".config"),
+    options.configDir ? resolve(cwd, options.configDir) : undefined
+  ].filter((directory) => Boolean(directory))));
+}
 function __exportSetter2(name, newValue) {
   this[name] = __returnValue2.bind(null, newValue);
 }
@@ -3433,7 +3463,7 @@ class ConfigCache2 {
   }
   isFileModified(configPath, cachedTimestamp) {
     try {
-      if (!existsSync2(configPath)) {
+      if (!existsSync3(configPath)) {
         return true;
       }
       const stats = statSync2(configPath);
@@ -3455,7 +3485,7 @@ class ConfigCache2 {
   }
   setWithFileCheck(configName, value, configPath, customTtl) {
     try {
-      const stats = existsSync2(configPath) ? statSync2(configPath) : null;
+      const stats = existsSync3(configPath) ? statSync2(configPath) : null;
       const fileTimestamp = stats ? stats.mtime : new Date;
       this.set(configName, { value, fileTimestamp }, configPath, customTtl);
     } catch {
@@ -3765,7 +3795,7 @@ async function loadConfig({
   ];
   for (const configPath of configPaths) {
     for (const ext of extensions) {
-      const fullPath = resolve(baseDir, `${configPath}${ext}`);
+      const fullPath = resolve5(baseDir, `${configPath}${ext}`);
       const config2 = await tryLoadConfig(fullPath, defaultConfig);
       if (config2 !== null) {
         return config2;
@@ -3773,7 +3803,7 @@ async function loadConfig({
     }
   }
   try {
-    const pkgPath = resolve(baseDir, "package.json");
+    const pkgPath = resolve5(baseDir, "package.json");
     if (existsSync22(pkgPath)) {
       const pkg = await import(pkgPath);
       const pkgConfig = pkg[name];
@@ -3787,12 +3817,12 @@ async function loadConfig({
   return defaultConfig;
 }
 function getProjectRoot(filePath, options = {}) {
-  let path = process2.cwd();
+  let path = process22.cwd();
   while (path.includes("storage"))
     path = resolve2(path, "..");
   const finalPath = resolve2(path, filePath || "");
   if (options?.relative)
-    return relative(process2.cwd(), finalPath);
+    return relative(process22.cwd(), finalPath);
   return finalPath;
 }
 async function loadConfig2() {
@@ -3800,7 +3830,7 @@ async function loadConfig2() {
     const loadedConfig = await loadConfig({
       name: "clarity",
       defaultConfig,
-      cwd: process2.cwd(),
+      cwd: process22.cwd(),
       endpoint: "",
       headers: {}
     });
@@ -5142,7 +5172,7 @@ function isObject2(item) {
   return Boolean(item && typeof item === "object" && !Array.isArray(item));
 }
 async function tryLoadConfig2(configPath, defaultConfig2, arrayStrategy = "replace") {
-  if (!existsSync3(configPath))
+  if (!existsSync32(configPath))
     return null;
   try {
     const importedConfig = await import(configPath);
@@ -5313,7 +5343,7 @@ async function loadConfig3({
   }
   try {
     const pkgPath = resolve3(baseDir, "package.json");
-    if (existsSync3(pkgPath)) {
+    if (existsSync32(pkgPath)) {
       const pkg = await import(pkgPath);
       let pkgConfig = pkg[name];
       if (!pkgConfig && alias) {
@@ -5604,7 +5634,7 @@ class Logger2 {
                 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((resolve52) => setTimeout(resolve52, delay));
+                await new Promise((resolve522) => setTimeout(resolve522, delay));
                 retries++;
                 continue;
               }
@@ -5632,7 +5662,7 @@ class Logger2 {
           }
           retries++;
           const delay = backoffDelay * 2 ** (retries - 1);
-          await new Promise((resolve52) => setTimeout(resolve52, delay));
+          await new Promise((resolve522) => setTimeout(resolve522, delay));
         }
       }
     })();
@@ -5762,11 +5792,11 @@ class Logger2 {
     };
   }
   async compressData(data) {
-    return new Promise((resolve52, reject) => {
+    return new Promise((resolve522, reject) => {
       const gzip = createGzip2();
       const chunks = [];
       gzip.on("data", (chunk2) => chunks.push(chunk2));
-      gzip.on("end", () => resolve52(Buffer22.from(Buffer22.concat(chunks))));
+      gzip.on("end", () => resolve522(Buffer22.from(Buffer22.concat(chunks))));
       gzip.on("error", reject);
       gzip.write(data);
       gzip.end();
@@ -6455,7 +6485,7 @@ class Logger2 {
     if (isBrowserProcess2()) {
       return Promise.resolve(true);
     }
-    return new Promise((resolve52) => {
+    return new Promise((resolve522) => {
       console.error(`${styles2.cyan("?")} ${message} (y/n) `);
       const onData = (data) => {
         const input = data.toString().trim().toLowerCase();
@@ -6467,7 +6497,7 @@ class Logger2 {
         } catch {}
         process11.stdin.pause();
         console.error("");
-        resolve52(input === "y" || input === "yes");
+        resolve522(input === "y" || input === "yes");
       };
       try {
         if (typeof process11.stdin.setRawMode === "function") {
@@ -6633,7 +6663,7 @@ async function withErrorRecovery(fn, options = {}) {
         break;
       }
       if (retryDelay > 0) {
-        await new Promise((resolve52) => setTimeout(resolve52, retryDelay));
+        await new Promise((resolve522) => setTimeout(resolve522, retryDelay));
       }
     }
   }
@@ -7161,7 +7191,7 @@ class ConfigFileLoader {
     const paths = [];
     for (const pattern of patterns) {
       for (const ext of this.extensions) {
-        paths.push(resolve5(directory, `${pattern}${ext}`));
+        paths.push(resolve52(directory, `${pattern}${ext}`));
       }
     }
     return paths;
@@ -7198,7 +7228,7 @@ class ConfigFileLoader {
       const patterns = this.generateNamePatterns(configName || "", alias);
       for (const pattern of patterns) {
         for (const ext of this.extensions) {
-          const filePath = resolve5(directory, `${pattern}${ext}`);
+          const filePath = resolve52(directory, `${pattern}${ext}`);
           if (await this.checkFileAccess(filePath)) {
             discoveredFiles.push(filePath);
           }
@@ -7210,7 +7240,7 @@ class ConfigFileLoader {
         const files = readdirSync32(directory);
         for (const file of files) {
           if (this.looksLikeConfigFile(file)) {
-            const filePath = resolve5(directory, file);
+            const filePath = resolve52(directory, file);
             if (await this.checkFileAccess(filePath)) {
               discoveredFiles.push(filePath);
             }
@@ -9935,7 +9965,7 @@ function isObject4(item) {
 }
 
 class ConfigFileLoader2 {
-  extensions = [".ts", ".js", ".mjs", ".cjs", ".json", ".mts", ".cts"];
+  extensions = CONFIG_FILE_EXTENSIONS;
   async loadFromPath(configPath, defaultConfig4, options = {}) {
     const {
       arrayStrategy = "replace",
@@ -10010,37 +10040,10 @@ class ConfigFileLoader2 {
     return null;
   }
   generateConfigPaths(configName, directory, alias) {
-    const patterns = this.generateNamePatterns(configName, alias);
-    const paths = [];
-    for (const pattern of patterns) {
-      for (const ext of this.extensions) {
-        paths.push(resolve10(directory, `${pattern}${ext}`));
-      }
-    }
-    return paths;
+    return getConfigPaths({ name: configName, directory, alias });
   }
   generateNamePatterns(configName, alias) {
-    const patterns = [];
-    patterns.push("config", ".config");
-    if (configName) {
-      patterns.push(configName, `.${configName}.config`, `${configName}.config`, `.${configName}`);
-    }
-    const aliases = alias === undefined ? [] : Array.isArray(alias) ? alias : [alias];
-    for (const a of aliases) {
-      if (!a)
-        continue;
-      patterns.push(a, `.${a}.config`, `${a}.config`, `.${a}`);
-      if (configName) {
-        patterns.push(`${configName}.${a}.config`, `.${configName}.${a}.config`);
-      }
-    }
-    const seen = new Set;
-    return patterns.filter((p) => {
-      if (!p || seen.has(p))
-        return false;
-      seen.add(p);
-      return true;
-    });
+    return getConfigNamePatterns({ name: configName, alias });
   }
   checkFileAccess(filePath) {
     return withErrorRecovery2(async () => {
@@ -10551,6 +10554,8 @@ class ConfigLoader2 {
       try {
         result = await this.loadConfigurationStrategies(baseOptions, true, cache);
       } catch (error) {
+        if (baseOptions.configFile)
+          throw error;
         const isStrictMode = baseOptions.__strictErrorHandling;
         if (error instanceof Error && error.name === "ConfigNotFoundError") {
           if (isStrictMode) {
@@ -10625,6 +10630,7 @@ class ConfigLoader2 {
     const {
       name = "",
       alias,
+      configFile,
       cwd,
       configDir,
       defaultConfig: defaultConfig4,
@@ -10634,6 +10640,17 @@ class ConfigLoader2 {
     } = options;
     const baseDir = cwd || process20.cwd();
     const searchPaths = [];
+    if (configFile) {
+      const explicitPath = resolve12(baseDir, configFile);
+      searchPaths.push(explicitPath);
+      const envDefaults = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig4, verbose) : defaultConfig4;
+      const explicitResult = await this.fileLoader.tryLoadFromPaths([explicitPath], envDefaults, { arrayStrategy, verbose, cacheTtl: cacheOptions?.ttl, useCache: !cacheOptions?.ttl || cacheOptions.ttl > 100 });
+      if (!explicitResult)
+        throw ErrorFactory2.configNotFound(name || configFile, searchPaths, alias);
+      if (verbose)
+        log3.success(`Configuration loaded from explicit path: ${explicitPath}`);
+      return this.finalizeResult(explicitResult, searchPaths, checkEnv, name, verbose);
+    }
     const localResult = await this.loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig4, arrayStrategy, verbose, checkEnv, cacheOptions);
     if (localResult) {
       searchPaths.push(...this.getLocalSearchPaths(name, alias, baseDir, configDir));
@@ -10821,6 +10838,8 @@ class ConfigLoader2 {
     }
     if (options.cwd)
       keyParts.push(`cwd:${options.cwd}`);
+    if (options.configFile)
+      keyParts.push(`configFile:${options.configFile}`);
     if (options.configDir)
       keyParts.push(`configDir:${options.configDir}`);
     if ("checkEnv" in options)
@@ -10828,12 +10847,7 @@ class ConfigLoader2 {
     return keyParts.join("|");
   }
   getLocalDirectories(baseDir, configDir) {
-    return Array.from(new Set([
-      baseDir,
-      resolve12(baseDir, "config"),
-      resolve12(baseDir, ".config"),
-      configDir ? resolve12(baseDir, configDir) : undefined
-    ].filter(Boolean)));
+    return getLocalConfigDirectories({ cwd: baseDir, configDir });
   }
   getAllSearchPaths(name, alias, baseDir, configDir) {
     const paths = [];
@@ -10885,6 +10899,8 @@ async function loadConfig6(options) {
     }
     return result?.config ?? defaultConfig4;
   } catch (error) {
+    if (options.configFile)
+      throw error;
     const errorName = error instanceof Error ? error.name : "UnknownError";
     const errorMessage = error instanceof Error ? error.message : String(error);
     const isConfigError = errorName === "ConfigNotFoundError" || errorName === "ConfigLoadError" || errorName === "ConfigValidationError" || errorMessage.includes("config");
@@ -10952,7 +10968,7 @@ function applyEnvVarsToConfig3(name, config6, verbose = false) {
   }
   return processConfigLevel(config6);
 }
-var globalCache, globalPerformanceMonitor, __defProp2, __returnValue2 = (v) => v, __export2 = (target, all) => {
+var globalCache, globalPerformanceMonitor, CONFIG_FILE_EXTENSIONS, __defProp2, __returnValue2 = (v) => v, __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
       get: all[name],
@@ -10964,6 +10980,15 @@ var globalCache, globalPerformanceMonitor, __defProp2, __returnValue2 = (v) => v
 var init_dist = __esm(() => {
   globalCache = new ConfigCache;
   globalPerformanceMonitor = new PerformanceMonitor;
+  CONFIG_FILE_EXTENSIONS = [
+    ".ts",
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".mts",
+    ".cts"
+  ];
   __defProp2 = Object.defineProperty;
   exports_dist = {};
   __export2(exports_dist, {
@@ -11016,9 +11041,9 @@ var init_dist = __esm(() => {
       isEquivalent: isEquivalent2,
       estimateMemoryUsage: estimateMemoryUsage2
     };
-    defaultConfigDir = resolve(process3.cwd(), "config");
-    defaultGeneratedDir = resolve(process3.cwd(), "src/generated");
-    defaultLogDirectory = process2.env.CLARITY_LOG_DIR || join(getProjectRoot(), "logs");
+    defaultConfigDir = resolve5(process3.cwd(), "config");
+    defaultGeneratedDir = resolve5(process3.cwd(), "src/generated");
+    defaultLogDirectory = process22.env.CLARITY_LOG_DIR || join(getProjectRoot(), "logs");
     defaultConfig = {
       level: "info",
       defaultName: "clarity",
@@ -11635,8 +11660,8 @@ var init_dist = __esm(() => {
     showTags: true
   });
   globalConfigLoader2 = new ConfigLoader2;
-  defaultConfigDir4 = resolve12(process20.cwd(), "config");
-  defaultGeneratedDir4 = resolve12(process20.cwd(), "src/generated");
+  defaultConfigDir4 = /* @__PURE__ */ resolve12(process20.cwd(), "config");
+  defaultGeneratedDir4 = /* @__PURE__ */ resolve12(process20.cwd(), "src/generated");
 });
 
 // src/config.ts
@@ -11644,6 +11669,29 @@ import process19 from "process";
 function isMysqlLike(dialect = config5.dialect) {
   return dialect === "mysql" || dialect === "singlestore" || dialect === "vitess";
 }
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function mergeObject(target, source, seen = new Set) {
+  const out = { ...target };
+  seen.add(source);
+  for (const key of Object.keys(source)) {
+    if (FORBIDDEN_MERGE_KEYS.has(key))
+      continue;
+    const next = source[key];
+    if (isPlainObject(next) && !seen.has(next)) {
+      const prev = out[key];
+      out[key] = mergeObject(isPlainObject(prev) ? prev : {}, next, seen);
+    } else {
+      out[key] = next;
+    }
+  }
+  seen.delete(source);
+  return out;
+}
 function resolveDialect(explicit) {
   if (explicit)
     return explicit;
@@ -11687,21 +11735,12 @@ async function getConfig() {
   return config5;
 }
 function applyConfig(userConfig) {
-  Object.assign(config5, userConfig);
-  if (userConfig.database) {
-    config5.database = { ...config5.database, ...userConfig.database };
-  }
-  if (userConfig.timestamps) {
-    config5.timestamps = { ...config5.timestamps, ...userConfig.timestamps };
-  }
-  if (userConfig.pagination) {
-    config5.pagination = { ...config5.pagination, ...userConfig.pagination };
-  }
-  if (userConfig.softDeletes) {
-    config5.softDeletes = { ...config5.softDeletes, ...userConfig.softDeletes };
-  }
-  if (userConfig.vitess) {
-    config5.vitess = { ...config5.vitess, ...userConfig.vitess };
+  const merged = mergeObject(config5, userConfig);
+  const target = config5;
+  for (const key of Object.keys(merged)) {
+    if (FORBIDDEN_MERGE_KEYS.has(key))
+      continue;
+    target[key] = merged[key];
   }
 }
 function setConfig(userConfig) {
@@ -11709,7 +11748,7 @@ function setConfig(userConfig) {
     const key = `${_lastConfiguredDialect}->${userConfig.dialect}`;
     if (!_warnedDialectConflicts.has(key)) {
       _warnedDialectConflicts.add(key);
-      console.warn(`[query-builder] setConfig({ dialect: '${userConfig.dialect}' }) overrides a previous ` + `setConfig({ dialect: '${_lastConfiguredDialect}' }). ` + `Config is process-wide; in-flight queries from the previous configuration may break. ` + `Run conflicting connections in separate processes \u2014 see stacksjs/stacks#1862 #18.`);
+      console.warn(`[query-builder] Configuring dialect '${userConfig.dialect}' overrides the previously ` + `configured dialect '${_lastConfiguredDialect}'. ` + `Config is process-wide (setConfig, db.configure and query-builder.config.ts all write it); ` + `in-flight queries from the previous configuration may break. ` + `Run conflicting connections in separate processes \u2014 see stacksjs/stacks#1862 #18.`);
     }
   }
   if (userConfig.dialect)
@@ -11718,7 +11757,10 @@ function setConfig(userConfig) {
     configState.explicit.add(key);
   applyConfig(userConfig);
 }
-var defaultConfig4, CONFIG_SINGLETON_KEY, config5, CONFIG_STATE_KEY, configState, _lastConfiguredDialect = null, _warnedDialectConflicts;
+function defineConfig(userConfig) {
+  return userConfig;
+}
+var defaultConfig4, FORBIDDEN_MERGE_KEYS, CONFIG_SINGLETON_KEY, config5, CONFIG_STATE_KEY, configState, _lastConfiguredDialect = null, _warnedDialectConflicts;
 var init_config = __esm(() => {
   init_dist();
   defaultConfig4 = {
@@ -11783,8 +11825,9 @@ var init_config = __esm(() => {
       defaultFilter: true
     }
   };
+  FORBIDDEN_MERGE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
   CONFIG_SINGLETON_KEY = Symbol.for("bun-query-builder.config");
-  config5 = globalThis[CONFIG_SINGLETON_KEY] ??= { ...defaultConfig4 };
+  config5 = globalThis[CONFIG_SINGLETON_KEY] ??= mergeObject({}, defaultConfig4);
   CONFIG_STATE_KEY = Symbol.for("bun-query-builder.config-state");
   configState = globalThis[CONFIG_STATE_KEY] ??= { explicit: new Set, fileLoaded: false };
   _warnedDialectConflicts = new Set;
@@ -11942,12 +11985,12 @@ function createSQLiteSQL(filename) {
     const params = [];
     for (let i = 0;i < values.length; i++) {
       const value = values[i];
-      if (value && typeof value === "object" && (value.__raw || value.raw)) {
-        const rawValue = value.__raw ? value.value : typeof value.raw === "string" ? value.raw : value.raw();
-        sql += rawValue + (strings[i + 1] || "");
-      } else if (value && typeof value === "object" && "sql" in value && "values" in value) {
+      if (value && typeof value === "object" && typeof value.sql === "string" && Array.isArray(value.values)) {
         sql += value.sql + (strings[i + 1] || "");
         params.push(...value.values);
+      } else if (value && typeof value === "object" && (value.__raw || value.raw)) {
+        const rawValue = value.__raw ? value.value : typeof value.raw === "string" ? value.raw : value.raw();
+        sql += rawValue + (strings[i + 1] || "");
       } else if (Array.isArray(value)) {
         const placeholders = value.map(() => "?").join(", ");
         sql += placeholders + (strings[i + 1] || "");
@@ -12582,6 +12625,11 @@ function renderSelectColumn(col) {
   }
   throw new TypeError(`[query-builder] select(): unsupported column ${String(col)} \u2014 pass a column name, a string[], or a SQL fragment (e.g. sql\`count(*) as c\`)`);
 }
+function renderInPredicate(column, values, negated, placeholders) {
+  if (values.length === 0)
+    return negated ? TRUE_PREDICATE : FALSE_PREDICATE;
+  return `${column} ${negated ? "NOT IN" : "IN"} (${placeholders})`;
+}
 function validateIdentifier(name, context) {
   if (!SQL_PATTERNS.IDENTIFIER.test(name)) {
     const contextMsg = context ? ` in ${context}` : "";
@@ -12827,6 +12875,20 @@ function createQueryBuilder(state) {
   const _sql = state?.sql ?? getOrCreateBunSql();
   const meta = state?.meta;
   const schema = state?.schema;
+  function advisoryLockKey(key) {
+    if (typeof key === "number")
+      return key;
+    const s = String(key);
+    let hash = 7;
+    for (let i = 0;i < s.length; i++)
+      hash = hash * 31 + s.charCodeAt(i) | 0;
+    return Math.abs(hash);
+  }
+  function activeHooks() {
+    if (!state?.hooks)
+      return config5.hooks;
+    return { ...config5.hooks, ...state.hooks };
+  }
   const dynamicWhereColumnCache = new Map;
   function applyCondition(expr) {
     if (Array.isArray(expr)) {
@@ -12918,7 +12980,7 @@ function createQueryBuilder(state) {
     return;
   }
   function runWithHooks(q, kind, opts) {
-    const hooks = config5.hooks;
+    const hooks = activeHooks();
     const slowMs = hooks?.slowQueryThresholdMs;
     const slowEnabled = slowMs != null && slowMs >= 0;
     const hasSlowQuery = Boolean(hooks?.onSlowQuery || slowEnabled);
@@ -14285,8 +14347,12 @@ function createQueryBuilder(state) {
         return this;
       },
       whereAny(cols, op, value) {
-        if (cols.length === 0)
+        if (cols.length === 0) {
+          const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
+          text += ` ${kw} (${FALSE_PREDICATE})`;
+          built = null;
           return this;
+        }
         const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const idx = whereParams.length + 1;
         const conds = cols.map((c, i) => `${c} ${op} ${getPlaceholder(idx + i)}`);
@@ -14368,7 +14434,7 @@ function createQueryBuilder(state) {
         const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` ${keyword} ${column} IN (${placeholders})`;
+          text += ` ${keyword} ${renderInPredicate(column, values, false, placeholders)}`;
           whereParams.push(...values);
         } else {
           text += ` ${keyword} ${column} IN (${String(values.toSQL())})`;
@@ -14380,7 +14446,7 @@ function createQueryBuilder(state) {
         validateIdentifier(String(column), "orWhereIn(column)");
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` OR ${column} IN (${placeholders})`;
+          text += ` OR ${renderInPredicate(column, values, false, placeholders)}`;
           whereParams.push(...values);
         } else {
           text += ` OR ${column} IN (${String(values.toSQL())})`;
@@ -14393,7 +14459,7 @@ function createQueryBuilder(state) {
         const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` ${keyword} ${column} NOT IN (${placeholders})`;
+          text += ` ${keyword} ${renderInPredicate(column, values, true, placeholders)}`;
           whereParams.push(...values);
         } else {
           text += ` ${keyword} ${column} NOT IN (${String(values.toSQL())})`;
@@ -14405,7 +14471,7 @@ function createQueryBuilder(state) {
         validateIdentifier(String(column), "orWhereNotIn(column)");
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` OR ${column} NOT IN (${placeholders})`;
+          text += ` OR ${renderInPredicate(column, values, true, placeholders)}`;
           whereParams.push(...values);
         } else {
           text += ` OR ${column} NOT IN (${String(values.toSQL())})`;
@@ -15000,7 +15066,7 @@ function createQueryBuilder(state) {
         return text;
       },
       async get() {
-        const hooks = config5.hooks;
+        const hooks = activeHooks();
         const hasQueryHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hasSlowQueryHook(hooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !hasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15053,7 +15119,7 @@ function createQueryBuilder(state) {
         return result;
       },
       async first() {
-        const fHooks = config5.hooks;
+        const fHooks = activeHooks();
         const fHasQueryHooks = fHooks && (fHooks.onQueryStart || fHooks.onQueryEnd || fHooks.onQueryError || fHooks.startSpan || hasSlowQueryHook(fHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !fHasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15135,7 +15201,7 @@ function createQueryBuilder(state) {
         } else {
           countText = `SELECT COUNT(*) as c FROM ${table}`;
         }
-        const cHooks = config5.hooks;
+        const cHooks = activeHooks();
         const cHasHooks = cHooks && (cHooks.onQueryStart || cHooks.onQueryEnd || cHooks.onQueryError || cHooks.startSpan || hasSlowQueryHook(cHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !cHasHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15153,7 +15219,7 @@ function createQueryBuilder(state) {
       async avg(column) {
         const fromIdx = text.indexOf(" FROM ");
         const avgText = fromIdx !== -1 ? `SELECT AVG(${column}) as a${text.substring(fromIdx)}` : `SELECT AVG(${column}) as a FROM ${table}`;
-        const aHooks = config5.hooks;
+        const aHooks = activeHooks();
         const aHasHooks = aHooks && (aHooks.onQueryStart || aHooks.onQueryEnd || aHooks.onQueryError || aHooks.startSpan || hasSlowQueryHook(aHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !aHasHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15290,7 +15356,7 @@ function createQueryBuilder(state) {
   }
   return {
     configure(opts) {
-      Object.assign(config5, opts);
+      setConfig(opts);
       return this;
     },
     id(name) {
@@ -15667,7 +15733,7 @@ function createQueryBuilder(state) {
           return makeExecutableQuery(built, sqlText);
         },
         execute() {
-          const hooks = config5.hooks;
+          const hooks = activeHooks();
           const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hooks.beforeCreate || hooks.afterCreate || hasSlowQueryHook(hooks));
           if (!hasHooks) {
             const prepareFn = _sql._prepareStatement;
@@ -16021,13 +16087,13 @@ function createQueryBuilder(state) {
         },
         async execute() {
           try {
-            await config5.hooks?.beforeDelete?.({ table: String(table), where: whereCondition });
+            await activeHooks()?.beforeDelete?.({ table: String(table), where: whereCondition });
           } catch (err) {
             throw err;
           }
           const result = mutationCount(await runWithHooks(ensureDelBuilt(), "delete"));
           try {
-            await config5.hooks?.afterDelete?.({ table: String(table), where: whereCondition, result });
+            await activeHooks()?.afterDelete?.({ table: String(table), where: whereCondition, result });
           } catch {}
           return result;
         },
@@ -16091,18 +16157,14 @@ function createQueryBuilder(state) {
     },
     async advisoryLock(key) {
       if (config5.dialect === "postgres") {
-        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 = bunSql`SELECT pg_advisory_lock(${k})`;
+        const k = advisoryLockKey(key);
+        const q = _sql`SELECT pg_advisory_lock(${k})`;
         await runWithHooks(q, "raw");
         return;
       }
       if (isMysqlLike(config5.dialect)) {
         const lockName = `bqb:${String(key)}`;
-        const q = bunSql`SELECT GET_LOCK(${lockName}, -1) AS ok`;
+        const q = _sql`SELECT GET_LOCK(${lockName}, -1) AS ok`;
         await runWithHooks(q, "raw");
         return;
       }
@@ -16110,18 +16172,29 @@ function createQueryBuilder(state) {
     },
     async tryAdvisoryLock(key) {
       if (config5.dialect === "postgres") {
-        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 = bunSql`SELECT pg_try_advisory_lock(${k}) as ok`;
+        const k = advisoryLockKey(key);
+        const q = _sql`SELECT pg_try_advisory_lock(${k}) as ok`;
         const rows = await runWithHooks(q, "raw");
         return Boolean(rows?.[0]?.ok);
       }
       if (isMysqlLike(config5.dialect)) {
         const lockName = `bqb:${String(key)}`;
-        const q = bunSql`SELECT GET_LOCK(${lockName}, 0) AS ok`;
+        const q = _sql`SELECT GET_LOCK(${lockName}, 0) AS ok`;
+        const rows = await runWithHooks(q, "raw");
+        return Number(rows?.[0]?.ok) === 1;
+      }
+      return false;
+    },
+    async advisoryUnlock(key) {
+      if (config5.dialect === "postgres") {
+        const k = advisoryLockKey(key);
+        const q = _sql`SELECT pg_advisory_unlock(${k}) as ok`;
+        const rows = await runWithHooks(q, "raw");
+        return Boolean(rows?.[0]?.ok);
+      }
+      if (isMysqlLike(config5.dialect)) {
+        const lockName = `bqb:${String(key)}`;
+        const q = _sql`SELECT RELEASE_LOCK(${lockName}) AS ok`;
         const rows = await runWithHooks(q, "raw");
         return Number(rows?.[0]?.ok) === 1;
       }
@@ -16131,11 +16204,11 @@ function createQueryBuilder(state) {
       return _sql.unsafe(query, params);
     },
     file(path, params) {
-      return bunSql.file(path, params);
+      return _sql.file(path, params);
     },
     async reserve() {
       const reserved = await bunSql.reserve();
-      const qb = createQueryBuilder({ sql: reserved, meta, schema });
+      const qb = createQueryBuilder({ sql: reserved, meta, schema, hooks: state?.hooks });
       qb.release = () => reserved.release();
       return qb;
     },
@@ -16155,7 +16228,7 @@ function createQueryBuilder(state) {
     },
     async ping() {
       try {
-        const q = bunSql`SELECT 1`;
+        const q = _sql`SELECT 1`;
         await runWithHooks(q, "select");
         return true;
       } catch {
@@ -16182,7 +16255,7 @@ function createQueryBuilder(state) {
         opts.logger?.({ type: "start", attempt: attempt2 });
         const start = Date.now();
         return await txConn[txMethod](async (tx) => {
-          const qb = createQueryBuilder({ sql: tx, meta, schema, inTransaction: true });
+          const qb = createQueryBuilder({ sql: tx, meta, schema, hooks: state?.hooks, inTransaction: true });
           if (opts?.isolation && !nested) {
             const level = opts.isolation;
             const upper = level === "read committed" ? "READ COMMITTED" : level === "repeatable read" ? "REPEATABLE READ" : "SERIALIZABLE";
@@ -16245,14 +16318,14 @@ function createQueryBuilder(state) {
       if (!s || typeof s.savepoint !== "function")
         throw new Error("savepoint() is not supported by the active connection");
       return await s.savepoint(async (sp) => {
-        const qb = createQueryBuilder({ sql: sp, meta, schema, inTransaction: true });
+        const qb = createQueryBuilder({ sql: sp, meta, schema, hooks: state?.hooks, inTransaction: true });
         return await fn(qb);
       });
     },
     async beginDistributed(name, fn) {
       const txConn = state?.sql ?? bunSql;
       const res = await txConn.beginDistributed(name, async (tx) => {
-        const qb = createQueryBuilder({ sql: tx, meta, schema });
+        const qb = createQueryBuilder({ sql: tx, meta, schema, hooks: state?.hooks });
         return await fn(qb);
       });
       return res;
@@ -16278,24 +16351,24 @@ function createQueryBuilder(state) {
       const { colsSql, valuesSql, params } = buildInsertClause(rows);
       const tbl = quoteInsertIdent(String(table));
       const sqlText = isMysqlLike(config5.dialect) ? `INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}` : `INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} ON CONFLICT DO NOTHING`;
-      return bunSql.unsafe(sqlText, params).execute();
+      return _sql.unsafe(sqlText, params).execute();
     },
     async insertGetId(table, values, idColumn = "id") {
       const { colsSql, valuesSql, params } = buildInsertClause([values]);
       const tbl = quoteInsertIdent(String(table));
       if (isMysqlLike(config5.dialect)) {
-        await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
-        const [row2] = await bunSql.unsafe(`SELECT LAST_INSERT_ID() as id`).execute();
+        await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        const [row2] = await _sql.unsafe(`SELECT LAST_INSERT_ID() as id`).execute();
         return row2?.id;
       }
       if (config5.dialect === "sqlite") {
-        const res = await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        const res = await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
         if (res?.lastInsertRowid != null)
           return res.lastInsertRowid;
-        const [row2] = await bunSql.unsafe(`SELECT last_insert_rowid() as id`).execute();
+        const [row2] = await _sql.unsafe(`SELECT last_insert_rowid() as id`).execute();
         return row2?.id;
       }
-      const [row] = await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} RETURNING ${quoteInsertIdent(String(idColumn))} as id`, params).execute();
+      const [row] = await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} RETURNING ${quoteInsertIdent(String(idColumn))} as id`, params).execute();
       return row?.id;
     },
     async updateOrInsert(table, match, values) {
@@ -16304,18 +16377,18 @@ function createQueryBuilder(state) {
       let idx = 1;
       const whereSql = matchKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(idx++)}`).join(" AND ");
       const whereParams = matchKeys.map((k) => match[k]);
-      const existsRows = await bunSql.unsafe(`SELECT 1 FROM ${tbl} WHERE ${whereSql} LIMIT 1`, whereParams).execute();
+      const existsRows = await _sql.unsafe(`SELECT 1 FROM ${tbl} WHERE ${whereSql} LIMIT 1`, whereParams).execute();
       if (existsRows.length) {
         const setKeys = Object.keys(values);
         let i = 1;
         const setSql = setKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(i++)}`).join(", ");
         const whereSql2 = matchKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(i++)}`).join(" AND ");
         const params2 = [...setKeys.map((k) => values[k]), ...matchKeys.map((k) => match[k])];
-        await bunSql.unsafe(`UPDATE ${tbl} SET ${setSql} WHERE ${whereSql2}`, params2).execute();
+        await _sql.unsafe(`UPDATE ${tbl} SET ${setSql} WHERE ${whereSql2}`, params2).execute();
         return true;
       }
       const { colsSql, valuesSql, params } = buildInsertClause([{ ...match, ...values }]);
-      await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+      await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
       return true;
     },
     async upsert(table, rows, conflictColumns, mergeColumns) {
@@ -16329,15 +16402,15 @@ function createQueryBuilder(state) {
       const insert = `INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`;
       if (isMysqlLike(config5.dialect)) {
         if (setCols.length === 0)
-          return bunSql.unsafe(`INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+          return _sql.unsafe(`INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
         const updateList2 = setCols.map((c) => `${quoteInsertIdent(c)} = VALUES(${quoteInsertIdent(c)})`).join(", ");
-        return bunSql.unsafe(`${insert} ON DUPLICATE KEY UPDATE ${updateList2}`, params).execute();
+        return _sql.unsafe(`${insert} ON DUPLICATE KEY UPDATE ${updateList2}`, params).execute();
       }
       const targets = targetCols.map(quoteInsertIdent).join(", ");
       if (setCols.length === 0)
-        return bunSql.unsafe(`${insert} ON CONFLICT (${targets}) DO NOTHING`, params).execute();
+        return _sql.unsafe(`${insert} ON CONFLICT (${targets}) DO NOTHING`, params).execute();
       const updateList = setCols.map((c) => `${quoteInsertIdent(c)} = EXCLUDED.${quoteInsertIdent(c)}`).join(", ");
-      return bunSql.unsafe(`${insert} ON CONFLICT (${targets}) DO UPDATE SET ${updateList}`, params).execute();
+      return _sql.unsafe(`${insert} ON CONFLICT (${targets}) DO UPDATE SET ${updateList}`, params).execute();
     },
     async save(table, values) {
       const pk = meta?.primaryKeys[String(table)] ?? "id";
@@ -16380,26 +16453,25 @@ function createQueryBuilder(state) {
     async rawQuery(query) {
       const start = Date.now();
       try {
-        config5.hooks?.onQueryStart?.({ sql: query, kind: "raw" });
-        const res = await bunSql.unsafe(query);
-        config5.hooks?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
+        activeHooks()?.onQueryStart?.({ sql: query, kind: "raw" });
+        const res = await _sql.unsafe(query);
+        activeHooks()?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
         return res;
       } catch (err) {
-        config5.hooks?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
+        activeHooks()?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
         throw err;
       }
     },
     async create(table, values) {
       const pk = meta?.primaryKeys[String(table)] ?? "id";
       try {
-        await config5.hooks?.beforeCreate?.({ table: String(table), data: values });
+        await activeHooks()?.beforeCreate?.({ table: String(table), data: values });
       } catch (err) {
         throw err;
       }
       if (config5.dialect === "postgres") {
-        const q = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)} RETURNING ${bunSql(String(pk))} as id`;
+        const q = _sql`INSERT INTO ${_sql(String(table))} ${_sql(values)} RETURNING ${_sql(String(pk))} as id`;
         const [result] = await q.execute();
-        console.log("resultId", result);
         if (!result?.id) {
           console.error(`create() failed to get insert ID for table ${String(table)}`);
           console.error("Inserted values:", values);
@@ -16412,7 +16484,7 @@ function createQueryBuilder(state) {
           throw new Error(`create() failed to retrieve inserted row for table ${String(table)} with id ${result.id}`);
         }
         try {
-          await config5.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
+          await activeHooks()?.afterCreate?.({ table: String(table), data: values, result: row });
         } catch {}
         return row;
       } else {
@@ -16427,7 +16499,7 @@ function createQueryBuilder(state) {
           throw new Error(`create() failed to retrieve inserted row for table ${String(table)} with id ${id}`);
         }
         try {
-          await config5.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
+          await activeHooks()?.afterCreate?.({ table: String(table), data: values, result: row });
         } catch {}
         return row;
       }
@@ -16567,28 +16639,28 @@ function createQueryBuilder(state) {
       return await this.create(table, { ...match, ...values });
     },
     async count(table, column) {
-      const col = column ? bunSql(String(column)) : bunSql`*`;
-      const q = bunSql`SELECT COUNT(${col}) as c FROM ${bunSql(String(table))}`;
+      const col = column ? _sql(String(column)) : _sql`*`;
+      const q = _sql`SELECT COUNT(${col}) as c FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return Number(row?.c ?? 0);
     },
     async sum(table, column) {
-      const q = bunSql`SELECT SUM(${bunSql(String(column))}) as s FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT SUM(${_sql(String(column))}) as s FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return Number(row?.s ?? 0);
     },
     async avg(table, column) {
-      const q = bunSql`SELECT AVG(${bunSql(String(column))}) as a FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT AVG(${_sql(String(column))}) as a FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return Number(row?.a ?? 0);
     },
     async min(table, column) {
-      const q = bunSql`SELECT MIN(${bunSql(String(column))}) as m FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT MIN(${_sql(String(column))}) as m FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return row?.m;
     },
     async max(table, column) {
-      const q = bunSql`SELECT MAX(${bunSql(String(column))}) as m FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT MAX(${_sql(String(column))}) as m FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return row?.m;
     },
@@ -16658,7 +16730,7 @@ function clearQueryCache() {
 function setQueryCacheMaxSize(size) {
   queryCache.setMaxSize(size);
 }
-var SQL_PATTERNS, SAFE_WHERE_OPERATORS, warnedSqlFragmentContexts, queryCache, reorderCache, REORDER_CACHE_MAX = 500;
+var FALSE_PREDICATE = "1 = 0", TRUE_PREDICATE = "1 = 1", SQL_PATTERNS, SAFE_WHERE_OPERATORS, warnedSqlFragmentContexts, queryCache, reorderCache, REORDER_CACHE_MAX = 500;
 var init_client = __esm(() => {
   init_config();
   init_db();
@@ -16751,7 +16823,7 @@ var init_cache = __esm(() => {
 });
 
 // src/actions/console.ts
-import process22 from "process";
+import process23 from "process";
 import { createInterface } from "readline";
 async function startConsole() {
   console.log("-- Query Builder Interactive Console");
@@ -16760,8 +16832,8 @@ async function startConsole() {
   console.log();
   const qb = createQueryBuilder();
   const rl = createInterface({
-    input: process22.stdin,
-    output: process22.stdout,
+    input: process23.stdin,
+    output: process23.stdout,
     prompt: "qb> "
   });
   let multilineBuffer = "";
@@ -16812,7 +16884,7 @@ Tips:
       if (cmd === ".exit" || cmd === ".quit") {
         console.log("Goodbye!");
         rl.close();
-        process22.exit(0);
+        process23.exit(0);
       } else if (cmd === ".help") {
         console.log(helpText);
       } else if (cmd === ".clear") {
@@ -16883,7 +16955,7 @@ Tips:
   rl.on("close", () => {
     console.log(`
 Goodbye!`);
-    process22.exit(0);
+    process23.exit(0);
   });
   rl.prompt();
 }
@@ -16895,7 +16967,7 @@ var init_console = __esm(() => {
 });
 
 // src/actions/data.ts
-import { existsSync as existsSync11, readFileSync as readFileSync2, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync8 } from "fs";
 async function exportData(tableName, options = {}) {
   const format = options.format || "json";
   const output = options.output || `${tableName}.${format}`;
@@ -16970,7 +17042,7 @@ async function exportData(tableName, options = {}) {
   }
 }
 async function importData(tableName, filePath, options = {}) {
-  if (!existsSync11(filePath)) {
+  if (!existsSync2(filePath)) {
     console.error(`-- File not found: ${filePath}`);
     throw new Error(`File not found: ${filePath}`);
   }
@@ -18116,23 +18188,23 @@ var init_introspect_db = __esm(() => {
 });
 
 // src/actions/make-model.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname7, join as join7 } from "path";
-import process23 from "process";
+import process25 from "process";
 function findWorkspaceRoot(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname7(currentPath)) {
-    if (existsSync14(join7(currentPath, "package.json"))) {
+    if (existsSync11(join7(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname7(currentPath);
   }
-  return process23.cwd();
+  return process25.cwd();
 }
 async function makeModel(name, options = {}) {
-  const workspaceRoot = findWorkspaceRoot(process23.cwd());
+  const workspaceRoot = findWorkspaceRoot(process25.cwd());
   const modelsDir = options.dir || join7(workspaceRoot, "app/Models");
-  if (!existsSync14(modelsDir)) {
+  if (!existsSync11(modelsDir)) {
     mkdirSync7(modelsDir, { recursive: true });
     console.log(`-- Created models directory: ${modelsDir}`);
   }
@@ -18140,7 +18212,7 @@ async function makeModel(name, options = {}) {
   const tableName = options.table || `${name.toLowerCase()}s`;
   const fileName = `${className}.ts`;
   const filePath = join7(modelsDir, fileName);
-  if (existsSync14(filePath)) {
+  if (existsSync11(filePath)) {
     console.error(`-- Model already exists: ${filePath}`);
     throw new Error(`Model already exists: ${filePath}`);
   }
@@ -18900,17 +18972,17 @@ var init_drivers = __esm(() => {
 });
 
 // src/workspace.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { dirname as dirname8, isAbsolute as isAbsolute3, join as join9 } from "path";
-import process24 from "process";
-function findWorkspaceRoot2(startPath = process24.cwd()) {
+import process26 from "process";
+function findWorkspaceRoot2(startPath = process26.cwd()) {
   let currentPath = startPath;
   while (currentPath !== dirname8(currentPath)) {
-    if (existsSync16(join9(currentPath, "package.json")))
+    if (existsSync14(join9(currentPath, "package.json")))
       return currentPath;
     currentPath = dirname8(currentPath);
   }
-  return process24.cwd();
+  return process26.cwd();
 }
 function getSqlDirectory(workspaceRoot, migrationDir = "database/migrations") {
   const configured = migrationDir || "database/migrations";
@@ -18929,10 +19001,10 @@ __export(exports_migrate, {
   copyModelsToGenerated: () => copyModelsToGenerated,
   clearGeneratedDirectory: () => clearGeneratedDirectory
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir } from "os";
 import { join as join10 } from "path";
-import process25 from "process";
+import process27 from "process";
 async function settleAppliedFiles(qb, dialect, files) {
   if (files.length === 0)
     return;
@@ -18970,7 +19042,7 @@ function getSnapshotPath(workspaceRoot, dialect) {
 }
 function loadPlanSnapshot(workspaceRoot, dialect) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (!existsSync17(snapshotPath)) {
+  if (!existsSync16(snapshotPath)) {
     return;
   }
   try {
@@ -18993,7 +19065,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
   const snapshotDir = getSnapshotDir(workspaceRoot);
   const hash = hashMigrationPlan(plan);
-  if (existsSync17(snapshotPath)) {
+  if (existsSync16(snapshotPath)) {
     try {
       const current = JSON.parse(readFileSync3(snapshotPath, "utf8"));
       if (current?.hash === hash && current?.dialect === dialect && current?.plan) {
@@ -19002,7 +19074,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
       }
     } catch {}
   }
-  if (!existsSync17(snapshotDir)) {
+  if (!existsSync16(snapshotDir)) {
     mkdirSync8(snapshotDir, { recursive: true });
     info(`-- Created snapshot directory: ${snapshotDir}`);
   }
@@ -19024,7 +19096,7 @@ function getWorkspaceRoot() {
 }
 function ensureSqlDirectory(workspaceRoot) {
   const sqlDir = getSqlDirectory(workspaceRoot, config5.migrationDir);
-  if (!existsSync17(sqlDir)) {
+  if (!existsSync16(sqlDir)) {
     mkdirSync8(sqlDir, { recursive: true });
     info(`-- Created SQL directory: ${sqlDir}`);
   }
@@ -19033,7 +19105,7 @@ function ensureSqlDirectory(workspaceRoot) {
 async function generateMigration(dir, opts = {}) {
   await getConfig();
   if (!dir) {
-    dir = join10(process25.cwd(), "app/Models");
+    dir = join10(process27.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const workspaceRoot = getWorkspaceRoot();
@@ -19048,7 +19120,7 @@ async function generateMigration(dir, opts = {}) {
     } else {
       const defaultStatePath = join10(dir, `.qb-migrations.${dialect}.json`);
       const statePath = String(opts.state || defaultStatePath);
-      if (existsSync17(statePath)) {
+      if (existsSync16(statePath)) {
         try {
           const raw2 = readFileSync3(statePath, "utf8");
           const parsed = JSON.parse(raw2);
@@ -19113,6 +19185,33 @@ async function generateMigration(dir, opts = {}) {
     savePlanSnapshot(workspaceRoot, dialect, plan);
   return { sql, sqlStatements, hasChanges, plan, operations };
 }
+function supportsTransactionalDdl(dialect) {
+  return dialect === "postgres" || dialect === "sqlite";
+}
+async function withMigrationLock(dialect, fn) {
+  if (dialect === "sqlite")
+    return await fn();
+  const qb = createQueryBuilder();
+  let reserved;
+  try {
+    reserved = await qb.reserve();
+  } catch {
+    return await fn();
+  }
+  let held = false;
+  try {
+    await reserved.advisoryLock(MIGRATION_LOCK_KEY);
+    held = true;
+    return await fn();
+  } finally {
+    try {
+      if (held)
+        await reserved.advisoryUnlock(MIGRATION_LOCK_KEY);
+    } finally {
+      reserved.release?.();
+    }
+  }
+}
 async function executeMigration(dir) {
   await getConfig();
   const workspaceRoot = getWorkspaceRoot();
@@ -19127,32 +19226,47 @@ async function executeMigration(dir) {
   info(`-- Found ${scriptFiles.length} script files to execute`);
   try {
     const qb = createQueryBuilder();
-    await createMigrationsTable(qb, dialect);
-    const executedMigrations = await getExecutedMigrations(qb, dialect);
-    const pending = scriptFiles.filter((file2) => !executedMigrations.includes(file2));
-    if (pending.length === 0) {
-      info("-- No pending migrations to execute");
-      return true;
-    }
-    info(`-- Executing ${pending.length} migration${pending.length === 1 ? "" : "s"}`);
-    for (const file2 of pending) {
-      const filePath = join10(sqlDir, file2);
-      info(`-- Executing: ${file2}`);
-      try {
-        await qb.file(filePath);
-        await recordMigration(qb, file2, dialect);
-        info(`-- \u2713 Migration ${file2} executed and recorded`);
-      } catch (err) {
-        if (isGeneratedMigration(sqlDir, file2) && isAlreadyAppliedError(err)) {
-          await recordMigration(qb, file2, dialect);
-          info(`-- \u2713 Migration ${file2} was already applied; recorded it (${err instanceof Error ? err.message : String(err)})`);
-          continue;
+    return await withMigrationLock(dialect, async () => {
+      await createMigrationsTable(qb, dialect);
+      const executedMigrations = await getExecutedMigrations(qb, dialect);
+      const pending = scriptFiles.filter((file2) => !executedMigrations.includes(file2));
+      if (pending.length === 0) {
+        info("-- No pending migrations to execute");
+        return true;
+      }
+      info(`-- Executing ${pending.length} migration${pending.length === 1 ? "" : "s"}`);
+      for (const file2 of pending) {
+        const filePath = join10(sqlDir, file2);
+        info(`-- Executing: ${file2}`);
+        try {
+          const wrappable = supportsTransactionalDdl(dialect) && !NON_TRANSACTIONAL_SQL.test(readFileSync3(filePath, "utf-8"));
+          if (wrappable) {
+            await qb.transaction(async (tx) => {
+              await tx.file(filePath);
+              await recordMigration(tx, file2, dialect);
+            });
+          } else {
+            await qb.file(filePath);
+            await recordMigration(qb, file2, dialect);
+            if (!supportsTransactionalDdl(dialect))
+              info(`--   (${dialect} commits DDL implicitly, so ${file2} was not applied atomically)`);
+            else
+              info(`--   (${file2} contains a statement that cannot run in a transaction, so it was not applied atomically)`);
+          }
+          info(`-- \u2713 Migration ${file2} executed and recorded`);
+        } catch (err) {
+          if (isGeneratedMigration(sqlDir, file2) && isAlreadyAppliedError(err)) {
+            await recordMigration(qb, file2, dialect);
+            info(`-- \u2713 Migration ${file2} was already applied; recorded it (${err instanceof Error ? err.message : String(err)})`);
+            continue;
+          }
+          console.error(`-- \u2717 Migration ${file2} failed:`, err);
+          throw err;
         }
-        console.error(`-- \u2717 Migration ${file2} failed:`, err);
-        throw err;
       }
-    }
-    info("-- All migrations executed successfully");
+      info("-- All migrations executed successfully");
+      return true;
+    });
   } catch (err) {
     console.error("-- Migration execution failed:", err);
     throw err;
@@ -19162,7 +19276,7 @@ async function executeMigration(dir) {
 async function resetDatabase(dir, opts = {}) {
   await getConfig();
   if (!dir) {
-    dir = join10(process25.cwd(), "app/Models");
+    dir = join10(process27.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
@@ -19259,27 +19373,27 @@ async function resetDatabase(dir, opts = {}) {
 }
 async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
   if (!dir) {
-    dir = join10(process25.cwd(), "app/Models");
+    dir = join10(process27.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
   const dialect = String(opts.dialect || config5.dialect || "postgres");
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (existsSync17(snapshotPath)) {
+  if (existsSync16(snapshotPath)) {
     unlinkSync(snapshotPath);
     info(`-- Removed model snapshot file: ${snapshotPath}`);
   }
   const defaultStatePath = join10(dir, `.qb-migrations.${dialect}.json`);
   const statePath = String(opts.state || defaultStatePath);
-  if (existsSync17(statePath)) {
+  if (existsSync16(statePath)) {
     unlinkSync(statePath);
     info(`-- Removed legacy migration state file: ${statePath}`);
   }
   removeGeneratedMigrationFiles(getSqlDirectory(workspaceRoot, config5.migrationDir));
 }
 function removeGeneratedMigrationFiles(sqlDir) {
-  if (!existsSync17(sqlDir))
+  if (!existsSync16(sqlDir))
     return;
   let removed = 0;
   const kept = [];
@@ -19302,7 +19416,7 @@ async function clearGeneratedDirectory(workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
   const generatedDir = join10(workspaceRoot, "generated");
-  if (existsSync17(generatedDir)) {
+  if (existsSync16(generatedDir)) {
     try {
       rmSync(generatedDir, { recursive: true, force: true });
       info("-- Cleared generated directory");
@@ -19343,6 +19457,7 @@ async function recordMigration(qb, migrationFile, dialect) {
     throw err;
   }
 }
+var MIGRATION_LOCK_KEY = "bun-query-builder:migrate", NON_TRANSACTIONAL_SQL;
 var init_migrate = __esm(() => {
   init_config();
   init_db();
@@ -19350,6 +19465,7 @@ var init_migrate = __esm(() => {
   init_src2();
   init_introspect_db();
   init_workspace();
+  NON_TRANSACTIONAL_SQL = /\bCONCURRENTLY\b|^\s*VACUUM\b/im;
 });
 
 // src/actions/migrate-generate.ts
@@ -19361,7 +19477,7 @@ var init_migrate_generate = __esm(() => {
 });
 
 // src/actions/migrate-rollback.ts
-import { existsSync as existsSync18, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
 import { join as join11 } from "path";
 function splitSqlStatements2(sql) {
   const out = [];
@@ -19476,7 +19592,7 @@ async function migrateRollback(options = {}) {
     for (const migration of migrationsToRollback) {
       try {
         const filePath = join11(sqlDir, migration.migration);
-        if (reverseSchema && existsSync18(filePath)) {
+        if (reverseSchema && existsSync17(filePath)) {
           const forwardSql = readFileSync4(filePath, "utf8");
           const { down, skipped } = deriveDownStatements(forwardSql);
           for (const stmt of down) {
@@ -19490,7 +19606,7 @@ async function migrateRollback(options = {}) {
         const deleteSql = `DELETE FROM migrations WHERE migration = ${getPlaceholder(1)}`;
         await qb.unsafe(deleteSql, [migration.migration]);
         console.log(`-- \u2713 Removed migration record: ${migration.migration}`);
-        if (options.deleteFiles && existsSync18(filePath)) {
+        if (options.deleteFiles && existsSync17(filePath)) {
           unlinkSync2(filePath);
           console.log(`-- \uD83D\uDDD1\uFE0F  Deleted migration file: ${migration.migration}`);
         }
@@ -19517,7 +19633,7 @@ var init_migrate_rollback = __esm(() => {
 });
 
 // src/actions/migrate-status.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
 async function migrateStatus() {
   const dialect = config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
@@ -19526,7 +19642,7 @@ async function migrateStatus() {
   console.log(`-- Dialect: ${dialect}`);
   console.log(`-- SQL directory: ${sqlDir}`);
   console.log();
-  if (!existsSync19(sqlDir)) {
+  if (!existsSync18(sqlDir)) {
     console.log("-- No SQL directory found. No migrations have been created yet.");
     return [];
   }
@@ -19591,9 +19707,9 @@ var init_migrate_status = __esm(() => {
 // src/actions/model-show.ts
 import { readdirSync as readdirSync9 } from "fs";
 import { extname as extname2, join as join12 } from "path";
-import process26 from "process";
+import process28 from "process";
 async function modelShow(modelName, options = {}) {
-  const dir = options.dir || join12(process26.cwd(), "app/Models");
+  const dir = options.dir || join12(process28.cwd(), "app/Models");
   try {
     const files = readdirSync9(dir);
     const modelFile = files.find((f) => {
@@ -19807,9 +19923,9 @@ var init_query_explain_all = __esm(() => {
 // src/actions/relation-diagram.ts
 import { writeFileSync as writeFileSync12 } from "fs";
 import { join as join14 } from "path";
-import process27 from "process";
+import process29 from "process";
 async function relationDiagram(options = {}) {
-  const dir = options.dir || join14(process27.cwd(), "app/Models");
+  const dir = options.dir || join14(process29.cwd(), "app/Models");
   const format = options.format || "mermaid";
   try {
     const models = await loadModels({ modelsDir: dir });
@@ -19929,21 +20045,21 @@ var init_relation_diagram = __esm(() => {
 });
 
 // src/actions/seed.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync9, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname10, join as join15 } from "path";
-import process28 from "process";
+import process30 from "process";
 function findWorkspaceRoot3(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname10(currentPath)) {
-    if (existsSync20(join15(currentPath, "package.json"))) {
+    if (existsSync19(join15(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname10(currentPath);
   }
-  return process28.cwd();
+  return process30.cwd();
 }
 async function loadSeeders(seedersDir) {
-  if (!existsSync20(seedersDir)) {
+  if (!existsSync19(seedersDir)) {
     console.log(`-- Seeders directory not found: ${seedersDir}`);
     return [];
   }
@@ -19973,7 +20089,7 @@ async function loadSeeders(seedersDir) {
   return seeders;
 }
 async function runSeeders(config6 = {}) {
-  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process30.cwd());
   const seedersDir = config6.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = config6.verbose ?? true;
   if (verbose) {
@@ -20008,7 +20124,7 @@ async function runSeeders(config6 = {}) {
   }
 }
 async function runSeeder(className, options = {}) {
-  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process30.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   if (verbose) {
@@ -20033,9 +20149,9 @@ async function runSeeder(className, options = {}) {
   }
 }
 async function makeSeeder(name) {
-  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process30.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
-  if (!existsSync20(seedersDir)) {
+  if (!existsSync19(seedersDir)) {
     mkdirSync9(seedersDir, { recursive: true });
     console.log(`-- Created seeders directory: ${seedersDir}`);
   }
@@ -20043,7 +20159,7 @@ async function makeSeeder(name) {
   const className = `${baseName}Seeder`;
   const fileName = `${className}.ts`;
   const filePath = join15(seedersDir, fileName);
-  if (existsSync20(filePath)) {
+  if (existsSync19(filePath)) {
     console.error(`-- Seeder already exists: ${filePath}`);
     throw new Error(`Seeder already exists: ${filePath}`);
   }
@@ -20097,7 +20213,7 @@ export default class ${className} extends Seeder {
   console.log(`-- \u2713 Created seeder: ${filePath}`);
 }
 async function freshDatabase(options = {}) {
-  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process30.cwd());
   const modelsDir = options.modelsDir || join15(workspaceRoot, "app/Models");
   const seedersDir = options.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
@@ -20157,22 +20273,22 @@ var init_unsafe = __esm(() => {
 });
 
 // src/actions/validate.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { dirname as dirname11, join as join16 } from "path";
-import process29 from "process";
+import process31 from "process";
 function findWorkspaceRoot4(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname11(currentPath)) {
-    if (existsSync21(join16(currentPath, "package.json"))) {
+    if (existsSync20(join16(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname11(currentPath);
   }
-  return process29.cwd();
+  return process31.cwd();
 }
 async function validateSchema(dir) {
   if (!dir) {
-    dir = join16(findWorkspaceRoot4(process29.cwd()), "app/Models");
+    dir = join16(findWorkspaceRoot4(process31.cwd()), "app/Models");
   }
   const dialect = config5.dialect || "postgres";
   console.log("-- Validating Schema");
@@ -25431,6 +25547,28 @@ function toTableName2(modelName) {
   tableNameCache.set(modelName, cached);
   return cached;
 }
+function relationNamesFor(definition, kind) {
+  const rel = definition[kind];
+  if (!rel)
+    return [];
+  if (Array.isArray(rel))
+    return rel.map((item) => typeof item === "string" ? item : String(item?.model ?? "")).filter(Boolean);
+  if (typeof rel === "object")
+    return Object.keys(rel);
+  if (typeof rel === "string")
+    return [rel];
+  return [];
+}
+function unresolvedRelationMessage(definition, relationName) {
+  const model = definition.name ?? definition.table ?? "model";
+  const declaredUnder = DECLARABLE_RELATION_KINDS.filter((kind) => relationNamesFor(definition, kind).some((n2) => n2.toLowerCase() === relationName.toLowerCase()));
+  const unsupported = declaredUnder.filter((k2) => !RESOLVABLE_RELATION_KINDS.includes(k2));
+  if (unsupported.length > 0) {
+    return `[orm] '${model}' declares '${relationName}' as ${unsupported.join("/")}, which eager loading does not support yet. ` + `Supported kinds: ${RESOLVABLE_RELATION_KINDS.join(", ")}. ` + `Load it with a manual query for now \u2014 see stacksjs/bun-query-builder#1068.`;
+  }
+  const available = RESOLVABLE_RELATION_KINDS.flatMap((kind) => relationNamesFor(definition, kind));
+  return available.length > 0 ? `[orm] '${model}' has no relation '${relationName}'. Available: ${available.join(", ")}.` : `[orm] '${model}' has no relation '${relationName}' \u2014 it declares no relations at all.`;
+}
 function resolveRelation(definition, relationName) {
   const parentName = definition.name;
   const parentTable = definition.table;
@@ -26165,7 +26303,7 @@ class ModelQueryBuilder {
       relationCache.set(cacheKey, rel);
     }
     if (!rel)
-      return;
+      throw new Error(unresolvedRelationMessage(this._definition, relationName));
     if (rel.type === "hasMany" || rel.type === "hasOne") {
       const parentIds = distinctParentIds(instances, pk);
       if (parentIds.length === 0)
@@ -26757,7 +26895,7 @@ async function seedModel(definition, count, faker) {
     await exec.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
   }
 }
-var SAFE_SQL_IDENTIFIER, _getModel = null, pgPlaceholderCache, PG_PLACEHOLDER_CACHE_MAX = 500, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, SOFT_DELETE_COLUMN = "deleted_at", BTM_RELATED_ALIAS = "__btm_rel__", btmKeysCache, snakeCaseCache, tableNameCache, relationCache, RELATION_CACHE_MAX = 1000;
+var SAFE_SQL_IDENTIFIER, _getModel = null, pgPlaceholderCache, PG_PLACEHOLDER_CACHE_MAX = 500, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, SOFT_DELETE_COLUMN = "deleted_at", BTM_RELATED_ALIAS = "__btm_rel__", btmKeysCache, snakeCaseCache, tableNameCache, relationCache, RELATION_CACHE_MAX = 1000, RESOLVABLE_RELATION_KINDS, DECLARABLE_RELATION_KINDS;
 var init_orm = __esm(() => {
   init_config();
   init_db();
@@ -26768,6 +26906,17 @@ var init_orm = __esm(() => {
   snakeCaseCache = new Map;
   tableNameCache = new Map;
   relationCache = new Map;
+  RESOLVABLE_RELATION_KINDS = ["hasMany", "hasOne", "belongsTo", "belongsToMany"];
+  DECLARABLE_RELATION_KINDS = [
+    ...RESOLVABLE_RELATION_KINDS,
+    "hasOneThrough",
+    "hasManyThrough",
+    "morphOne",
+    "morphMany",
+    "morphTo",
+    "morphToMany",
+    "morphedByMany"
+  ];
 });
 
 // src/model.ts
@@ -28217,7 +28366,7 @@ var init_factory = () => {};
 // src/loader.ts
 import { readdirSync as readdirSync12 } from "fs";
 import { basename, extname as extname4, isAbsolute as isAbsolute5, join as join17 } from "path";
-import process30 from "process";
+import process33 from "process";
 function isModelFile(name) {
   const ext = extname4(name);
   if (!MODEL_EXTENSIONS.has(ext))
@@ -28248,7 +28397,7 @@ function collectModelFiles(dir) {
   return files;
 }
 async function loadModels(options) {
-  const cwd = options.cwd ?? process30.cwd();
+  const cwd = options.cwd ?? process33.cwd();
   const dir = isAbsolute5(options.modelsDir) ? options.modelsDir : join17(cwd, options.modelsDir);
   const result = {};
   for (const full of collectModelFiles(dir)) {
@@ -28355,9 +28504,9 @@ function buildSchemaMeta(models) {
 var init_meta = () => {};
 
 // src/migrations.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync10, readdirSync as readdirSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync10, readdirSync as readdirSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync14 } from "fs";
 import { dirname as dirname12, join as join18 } from "path";
-import process31 from "process";
+import process35 from "process";
 function info2(message) {
   if (config5.verbose)
     console.log(message);
@@ -28374,17 +28523,17 @@ function lastCreatedMigrationFiles() {
 function findWorkspaceRoot5(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname12(currentPath)) {
-    if (existsSync23(join18(currentPath, "package.json"))) {
+    if (existsSync21(join18(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname12(currentPath);
   }
-  return process31.cwd();
+  return process35.cwd();
 }
 function ensureSqlDirectory2() {
-  const workspaceRoot = findWorkspaceRoot5(process31.cwd());
+  const workspaceRoot = findWorkspaceRoot5(process35.cwd());
   const sqlDir = getSqlDirectory(workspaceRoot, config5.migrationDir);
-  if (!existsSync23(sqlDir)) {
+  if (!existsSync21(sqlDir)) {
     mkdirSync10(sqlDir, { recursive: true });
     info2(`-- Created SQL directory: ${sqlDir}`);
   }
@@ -28429,7 +28578,7 @@ function createMigrationFile(statement, fileName) {
   let fullFileName = `${sequence}-${fileName}.sql`;
   if (!useDeterministicNames) {
     let next = Number(sequence);
-    while (existsSync23(join18(sqlDir, fullFileName))) {
+    while (existsSync21(join18(sqlDir, fullFileName))) {
       next += 1;
       sequence = String(next);
       fullFileName = `${sequence}-${fileName}.sql`;
@@ -29751,6 +29900,7 @@ export {
   defineSeeder,
   defineModels,
   defineModel,
+  defineConfig,
   defaultConfig4 as defaultConfig,
   dbWipe,
   dbStats,