bun-query-builder 0.2.25 → 0.2.27

package/dist/bin/cli.js

@@ -3049,25 +3049,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";
@@ -3091,7 +3093,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";
@@ -3351,6 +3353,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);
 }
@@ -3434,7 +3464,7 @@ class ConfigCache2 {
   }
   isFileModified(configPath, cachedTimestamp) {
     try {
-      if (!existsSync2(configPath)) {
+      if (!existsSync3(configPath)) {
         return true;
       }
       const stats = statSync2(configPath);
@@ -3456,7 +3486,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 {
@@ -3766,7 +3796,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;
@@ -3774,7 +3804,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];
@@ -3788,12 +3818,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() {
@@ -3801,7 +3831,7 @@ async function loadConfig2() {
     const loadedConfig = await loadConfig({
       name: "clarity",
       defaultConfig,
-      cwd: process2.cwd(),
+      cwd: process22.cwd(),
       endpoint: "",
       headers: {}
     });
@@ -5143,7 +5173,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);
@@ -5314,7 +5344,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) {
@@ -5605,7 +5635,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;
               }
@@ -5633,7 +5663,7 @@ class Logger2 {
           }
           retries++;
           const delay = backoffDelay * 2 ** (retries - 1);
-          await new Promise((resolve52) => setTimeout(resolve52, delay));
+          await new Promise((resolve522) => setTimeout(resolve522, delay));
         }
       }
     })();
@@ -5763,11 +5793,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();
@@ -6456,7 +6486,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();
@@ -6468,7 +6498,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") {
@@ -6634,7 +6664,7 @@ async function withErrorRecovery(fn, options = {}) {
         break;
       }
       if (retryDelay > 0) {
-        await new Promise((resolve52) => setTimeout(resolve52, retryDelay));
+        await new Promise((resolve522) => setTimeout(resolve522, retryDelay));
       }
     }
   }
@@ -7162,7 +7192,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;
@@ -7199,7 +7229,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);
           }
@@ -7211,7 +7241,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);
             }
@@ -9936,7 +9966,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",
@@ -10011,37 +10041,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 () => {
@@ -10552,6 +10555,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) {
@@ -10626,6 +10631,7 @@ class ConfigLoader2 {
     const {
       name = "",
       alias,
+      configFile,
       cwd,
       configDir,
       defaultConfig: defaultConfig4,
@@ -10635,6 +10641,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));
@@ -10822,6 +10839,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)
@@ -10829,12 +10848,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 = [];
@@ -10886,6 +10900,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");
@@ -10953,7 +10969,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],
@@ -10965,6 +10981,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, {
@@ -11017,9 +11042,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",
@@ -11636,8 +11661,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
@@ -11645,6 +11670,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;
@@ -11688,21 +11736,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) {
@@ -11710,7 +11749,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)
@@ -11719,7 +11758,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 = {
@@ -11784,8 +11826,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;
@@ -11943,12 +11986,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] || "");
@@ -12583,6 +12626,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}` : "";
@@ -12828,6 +12876,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)) {
@@ -12919,7 +12981,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);
@@ -14286,8 +14348,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)}`);
@@ -14369,7 +14435,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())})`;
@@ -14381,7 +14447,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())})`;
@@ -14394,7 +14460,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())})`;
@@ -14406,7 +14472,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())})`;
@@ -15001,7 +15067,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;
@@ -15054,7 +15120,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;
@@ -15136,7 +15202,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;
@@ -15154,7 +15220,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;
@@ -15291,7 +15357,7 @@ function createQueryBuilder(state) {
   }
   return {
     configure(opts) {
-      Object.assign(config5, opts);
+      setConfig(opts);
       return this;
     },
     id(name) {
@@ -15668,7 +15734,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;
@@ -16022,13 +16088,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;
         },
@@ -16092,18 +16158,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;
       }
@@ -16111,18 +16173,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;
       }
@@ -16132,11 +16205,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;
     },
@@ -16156,7 +16229,7 @@ function createQueryBuilder(state) {
     },
     async ping() {
       try {
-        const q = bunSql`SELECT 1`;
+        const q = _sql`SELECT 1`;
         await runWithHooks(q, "select");
         return true;
       } catch {
@@ -16183,7 +16256,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";
@@ -16246,14 +16319,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;
@@ -16279,24 +16352,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) {
@@ -16305,18 +16378,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) {
@@ -16330,15 +16403,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";
@@ -16381,26 +16454,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);
@@ -16413,7 +16485,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 {
@@ -16428,7 +16500,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;
       }
@@ -16568,28 +16640,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;
     },
@@ -16659,7 +16731,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();
@@ -16752,7 +16824,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");
@@ -16761,8 +16833,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 = "";
@@ -16813,7 +16885,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") {
@@ -16884,7 +16956,7 @@ Tips:
   rl.on("close", () => {
     console.log(`
 Goodbye!`);
-    process22.exit(0);
+    process23.exit(0);
   });
   rl.prompt();
 }
@@ -16896,7 +16968,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}`;
@@ -16971,7 +17043,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}`);
   }
@@ -18117,23 +18189,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}`);
   }
@@ -18141,7 +18213,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}`);
   }
@@ -18901,17 +18973,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";
@@ -18930,10 +19002,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;
@@ -18971,7 +19043,7 @@ function getSnapshotPath(workspaceRoot, dialect) {
 }
 function loadPlanSnapshot(workspaceRoot, dialect) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (!existsSync17(snapshotPath)) {
+  if (!existsSync16(snapshotPath)) {
     return;
   }
   try {
@@ -18994,7 +19066,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) {
@@ -19003,7 +19075,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
       }
     } catch {}
   }
-  if (!existsSync17(snapshotDir)) {
+  if (!existsSync16(snapshotDir)) {
     mkdirSync8(snapshotDir, { recursive: true });
     info(`-- Created snapshot directory: ${snapshotDir}`);
   }
@@ -19025,7 +19097,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}`);
   }
@@ -19034,7 +19106,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();
@@ -19049,7 +19121,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);
@@ -19114,6 +19186,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();
@@ -19128,32 +19227,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;
@@ -19163,7 +19277,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);
@@ -19260,27 +19374,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 = [];
@@ -19303,7 +19417,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");
@@ -19344,6 +19458,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();
@@ -19351,6 +19466,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
@@ -19362,7 +19478,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 = [];
@@ -19477,7 +19593,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) {
@@ -19491,7 +19607,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}`);
         }
@@ -19518,7 +19634,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);
@@ -19527,7 +19643,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 [];
   }
@@ -19592,9 +19708,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) => {
@@ -19808,9 +19924,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 });
@@ -19930,21 +20046,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 [];
   }
@@ -19974,7 +20090,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) {
@@ -20009,7 +20125,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) {
@@ -20034,9 +20150,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}`);
   }
@@ -20044,7 +20160,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}`);
   }
@@ -20098,7 +20214,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;
@@ -20158,22 +20274,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");
@@ -25432,6 +25548,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;
@@ -26166,7 +26304,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)
@@ -26758,7 +26896,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();
@@ -26769,6 +26907,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
@@ -28218,7 +28367,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))
@@ -28249,7 +28398,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)) {
@@ -28356,9 +28505,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);
@@ -28375,17 +28524,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}`);
   }
@@ -28430,7 +28579,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`;
@@ -29652,14 +29801,14 @@ var init_src2 = __esm(() => {
 });
 
 // ../../node_modules/@stacksjs/clapp/dist/index.js
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import process33 from "process";
+import process36 from "process";
 import { EventEmitter } from "events";
 import process52 from "process";
-import process210 from "process";
+import process24 from "process";
 import process34 from "process";
 import process42 from "process";
 import process72 from "process";
@@ -29680,10 +29829,10 @@ class Telemetry {
     this.configPath = path.join(configDir, "telemetry.json");
   }
   async isEnabled() {
-    if (process33.env.DO_NOT_TRACK === "1" || process33.env.DO_NOT_TRACK === "true") {
+    if (process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true") {
       return false;
     }
-    if (process33.env.NO_TELEMETRY === "1" || process33.env.NO_TELEMETRY === "true") {
+    if (process36.env.NO_TELEMETRY === "1" || process36.env.NO_TELEMETRY === "true") {
       return false;
     }
     const config6 = await this.loadConfig();
@@ -29712,7 +29861,7 @@ class Telemetry {
       ...data,
       timestamp: Date.now(),
       platform: os.platform(),
-      nodeVersion: process33.version
+      nodeVersion: process36.version
     };
     this.events.push(telemetryEvent);
     if (this.events.length >= 10) {
@@ -29768,7 +29917,7 @@ class Telemetry {
     const config6 = await this.loadConfig();
     return {
       enabled: config6.enabled,
-      doNotTrack: process33.env.DO_NOT_TRACK === "1" || process33.env.DO_NOT_TRACK === "true",
+      doNotTrack: process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true",
       eventsQueued: this.events.length,
       lastSent: config6.lastSent
     };
@@ -29778,7 +29927,7 @@ class Telemetry {
       return this.config;
     }
     try {
-      if (existsSync25(this.configPath)) {
+      if (existsSync23(this.configPath)) {
         const data = await fs.readFile(this.configPath, "utf-8");
         this.config = JSON.parse(data);
         return this.config;
@@ -29804,90 +29953,6 @@ class Telemetry {
   }
 }
 var telemetry = new Telemetry;
-function parseArgv(argv, opts = {}) {
-  const result = { _: [] };
-  const alias = opts.alias || {};
-  const booleans = new Set(opts.boolean || []);
-  const aliasOf = {};
-  for (const key of Object.keys(alias)) {
-    for (const a2 of alias[key]) {
-      aliasOf[a2] = key;
-    }
-  }
-  for (const b2 of booleans) {
-    if (alias[b2]) {
-      for (const a2 of alias[b2])
-        booleans.add(a2);
-    }
-  }
-  function setKey(key, value) {
-    const canonical = aliasOf[key] || key;
-    result[canonical] = value;
-    if (alias[canonical]) {
-      for (const a2 of alias[canonical])
-        result[a2] = value;
-    }
-    if (aliasOf[key] && alias[aliasOf[key]]) {
-      for (const a2 of alias[aliasOf[key]])
-        result[a2] = value;
-    }
-    result[key] = value;
-  }
-  for (let i2 = 0;i2 < argv.length; i2++) {
-    const arg = argv[i2];
-    if (arg === "--") {
-      result._.push(...argv.slice(i2 + 1));
-      break;
-    }
-    if (arg.startsWith("--")) {
-      const eqIdx = arg.indexOf("=");
-      if (eqIdx !== -1) {
-        const key = arg.slice(2, eqIdx);
-        const value = arg.slice(eqIdx + 1);
-        setKey(key, value);
-      } else {
-        const key = arg.slice(2);
-        if (key.startsWith("no-")) {
-          const actualKey = key.slice(3);
-          setKey(actualKey, false);
-          continue;
-        }
-        const canonical = aliasOf[key] || key;
-        if (booleans.has(canonical) || booleans.has(key)) {
-          setKey(key, true);
-        } else {
-          const next = argv[i2 + 1];
-          if (next !== undefined && !next.startsWith("-")) {
-            setKey(key, next);
-            i2++;
-          } else {
-            setKey(key, true);
-          }
-        }
-      }
-    } else if (arg.startsWith("-") && arg.length > 1) {
-      const chars = arg.slice(1);
-      for (let j = 0;j < chars.length; j++) {
-        const ch = chars[j];
-        const canonical = aliasOf[ch] || ch;
-        if (j === chars.length - 1 && !booleans.has(canonical) && !booleans.has(ch)) {
-          const next = argv[i2 + 1];
-          if (next !== undefined && !next.startsWith("-")) {
-            setKey(ch, next);
-            i2++;
-          } else {
-            setKey(ch, true);
-          }
-        } else {
-          setKey(ch, true);
-        }
-      }
-    } else {
-      result._.push(arg);
-    }
-  }
-  return result;
-}
 function removeBrackets(v2) {
   return v2.replace(/[<[].+/, "").trim();
 }
@@ -29984,9 +30049,13 @@ function camelcaseOptionName(name) {
 class ClappError extends Error {
   exitCode = 2;
   isUsageError = true;
-  constructor(message) {
+  usage;
+  constructor(message, usage) {
     super(message);
     this.name = this.constructor.name;
+    if (usage !== undefined) {
+      this.usage = usage;
+    }
     if (typeof Error.captureStackTrace === "function") {
       Error.captureStackTrace(this, this.constructor);
     } else {
@@ -30003,10 +30072,16 @@ ${this.stack}`;
     return this.message;
   }
 }
+function isClappError(err) {
+  if (err instanceof ClappError) {
+    return true;
+  }
+  return !!err && typeof err === "object" && err.name === "ClappError" && typeof err.message === "string";
+}
 function isUnicodeSupported() {
-  const { env } = process210;
+  const { env } = process24;
   const { TERM, TERM_PROGRAM } = env;
-  if (process210.platform !== "win32") {
+  if (process24.platform !== "win32") {
     return TERM !== "linux";
   }
   return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
@@ -30084,6 +30159,91 @@ function levenshteinDistance(a2, b2) {
 function findSimilarCommands(input, commands, maxDistance = 2, maxSuggestions = 3) {
   return commands.map((cmd) => ({ cmd, distance: levenshteinDistance(input, cmd) })).filter(({ distance }) => distance <= maxDistance).sort((a2, b2) => a2.distance - b2.distance).slice(0, maxSuggestions).map(({ cmd }) => cmd);
 }
+function parseArgv(argv, opts = {}) {
+  const result = { _: [] };
+  const alias = opts.alias || {};
+  const booleans = new Set(opts.boolean || []);
+  const aliasOf = {};
+  for (const key of Object.keys(alias)) {
+    for (const a2 of alias[key]) {
+      aliasOf[a2] = key;
+    }
+  }
+  for (const b2 of booleans) {
+    if (alias[b2]) {
+      for (const a2 of alias[b2])
+        booleans.add(a2);
+    }
+  }
+  function setKey(key, value) {
+    const canonical = aliasOf[key] || key;
+    result[canonical] = value;
+    if (alias[canonical]) {
+      for (const a2 of alias[canonical])
+        result[a2] = value;
+    }
+    if (aliasOf[key] && alias[aliasOf[key]]) {
+      for (const a2 of alias[aliasOf[key]])
+        result[a2] = value;
+    }
+    result[key] = value;
+  }
+  for (let i2 = 0;i2 < argv.length; i2++) {
+    const arg = argv[i2];
+    if (arg === "--") {
+      result._.push(...argv.slice(i2 + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = camelcase(arg.slice(2, eqIdx));
+        const value = arg.slice(eqIdx + 1);
+        setKey(key, value);
+      } else {
+        const rawKey = arg.slice(2);
+        if (rawKey.startsWith("no-")) {
+          const actualKey = camelcase(rawKey.slice(3));
+          setKey(actualKey, false);
+          continue;
+        }
+        const key = camelcase(rawKey);
+        const canonical = aliasOf[key] || key;
+        if (booleans.has(canonical) || booleans.has(key)) {
+          setKey(key, true);
+        } else {
+          const next = argv[i2 + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            setKey(key, next);
+            i2++;
+          } else {
+            setKey(key, true);
+          }
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const chars = arg.slice(1);
+      for (let j = 0;j < chars.length; j++) {
+        const ch = chars[j];
+        const canonical = aliasOf[ch] || ch;
+        if (j === chars.length - 1 && !booleans.has(canonical) && !booleans.has(ch)) {
+          const next = argv[i2 + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            setKey(ch, next);
+            i2++;
+          } else {
+            setKey(ch, true);
+          }
+        } else {
+          setKey(ch, true);
+        }
+      }
+    } else {
+      result._.push(arg);
+    }
+  }
+  return result;
+}
 
 class Option {
   rawName;
@@ -30231,9 +30391,9 @@ class Command {
     return this.namespace ? `${this.namespace}:${this.name}` : this.name;
   }
   hasOption(name) {
-    name = name.split(".")[0];
+    const normalized = camelcaseOptionName(name.split(".")[0]);
     return !!this.options.find((option) => {
-      return option.names.includes(name);
+      return option.names.some((optionName) => camelcaseOptionName(optionName) === normalized);
     });
   }
   outputHelp() {
@@ -30268,6 +30428,7 @@ class Command {
         }
       }
       let commandBody = "";
+      noNamespaceCommands.sort((a2, b2) => a2.rawName < b2.rawName ? -1 : a2.rawName > b2.rawName ? 1 : 0);
       if (noNamespaceCommands.length > 0) {
         commandBody += noNamespaceCommands.map((command) => {
           return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
@@ -30294,12 +30455,14 @@ class Command {
         body: commandBody
       });
       sections.push({
-        title: `For more info, run any command with the \`--help\` flag`,
-        body: commands.map((command) => `  $ ${name}${command.displayName === "" ? "" : ` ${command.displayName}`} --help`).join(`
-`)
+        body: `Run \`${name} <command> --help\` for command details.`
       });
     }
-    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    const localOptionNames = new Set(this.options.flatMap((option) => option.names));
+    let options = this.isGlobalCommand ? globalOptions : [
+      ...this.options,
+      ...(globalOptions || []).filter((option) => !option.names.some((name2) => localOptionNames.has(name2)))
+    ];
     if (!this.isGlobalCommand && !this.isDefaultCommand) {
       options = options.filter((option) => option.name !== "version");
     }
@@ -30343,6 +30506,9 @@ ${section.body}` : section.body;
       console.log(`${name}/${versionNumber} ${platformInfo3}`);
     }
   }
+  get usageLine() {
+    return `$ ${this.cli.name} ${this.usageText || this.rawName}`;
+  }
   checkRequiredArgs() {
     const minimalArgsCount = this.args.filter((arg) => arg.required).length;
     if (this.cli.args.length < minimalArgsCount) {
@@ -30351,7 +30517,7 @@ ${section.body}` : section.body;
       const argNames = missingArgs.map((arg) => `<${arg.value}>`).join(" ");
       throw new ClappError(`Missing required argument${missingArgs.length > 1 ? "s" : ""}: ${argNames}
 
-` + `Run \`${this.cli.name} ${this.rawName} --help\` for usage information.`);
+` + `Run \`${this.cli.name} ${this.rawName} --help\` for usage information.`, this.usageLine);
     }
   }
   checkUnknownOptions() {
@@ -30361,8 +30527,9 @@ ${section.body}` : section.body;
         if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
           const allOptions = [...globalCommand.options, ...this.options];
           const allOptionNames = allOptions.flatMap((opt) => opt.names);
+          const normalizedName = camelcaseOptionName(name.split(".")[0]);
           const optionFlag = name.length > 1 ? `--${name}` : `-${name}`;
-          const suggestions = findSimilarCommands(name, allOptionNames);
+          const suggestions = findSimilarCommands(normalizedName, allOptionNames);
           let errorMsg = `Unknown option \`${optionFlag}\``;
           if (suggestions.length > 0) {
             errorMsg += `
@@ -30377,7 +30544,7 @@ Did you mean one of these?`;
           errorMsg += `
 
 Run \`${this.cli.name} ${this.rawName} --help\` to see available options.`;
-          throw new ClappError(errorMsg);
+          throw new ClappError(errorMsg, this.usageLine);
         }
       }
     }
@@ -30392,7 +30559,7 @@ Run \`${this.cli.name} ${this.rawName} --help\` to see available options.`;
         if (value === true || value === false && !hasNegated) {
           throw new ClappError(`Option \`${option.rawName}\` requires a value.
 
-` + `Example: ${this.cli.name} ${this.rawName} ${option.rawName} <value>`);
+` + `Example: ${this.cli.name} ${this.rawName} ${option.rawName} <value>`, this.usageLine);
         }
       }
     }
@@ -30698,6 +30865,25 @@ Received ${signal}, cleaning up...`);
           break;
         }
       }
+      if (shouldParse) {
+        const nextToken = slicedArgv[1];
+        if (nextToken && !nextToken.startsWith("-")) {
+          const joinedName = `${candidateName}:${nextToken}`;
+          for (const command of this.commands) {
+            if (command.isMatched(joinedName)) {
+              const parsed = this.mri(slicedArgv, command);
+              shouldParse = false;
+              const parsedInfo = {
+                ...parsed,
+                args: parsed.args.slice(2)
+              };
+              this.setParsedInfo(parsedInfo, command, joinedName);
+              this.emit(`command:${joinedName}`, command);
+              break;
+            }
+          }
+        }
+      }
     }
     if (shouldParse) {
       for (const command of this.commands) {
@@ -30723,7 +30909,7 @@ Received ${signal}, cleaning up...`);
     if (this.options.debug) {
       this.isDebug = true;
     }
-    if (this.options.noInteraction) {
+    if (this.options.noInteraction || this.options.interaction === false) {
       this.isNoInteraction = true;
     }
     if (this.options.env) {
@@ -30735,14 +30921,14 @@ Received ${signal}, cleaning up...`);
     if (this.options.force) {
       this.isForce = true;
     }
-    if (this.options.noEmoji !== undefined) {
-      this.useEmoji = !this.options.noEmoji;
+    if (this.options.noEmoji || this.options.emoji === false) {
+      this.useEmoji = false;
     }
     if (this.options.theme) {
       this.theme = String(this.options.theme);
     }
-    if (this.options.noCache !== undefined) {
-      this.isNoCache = Boolean(this.options.noCache);
+    if (this.options.noCache || this.options.cache === false) {
+      this.isNoCache = true;
     }
     if (this.options.help && this.showHelpOnExit) {
       this.outputHelp();
@@ -30823,18 +31009,16 @@ Received ${signal}, cleaning up...`);
     return this.parse(argv, { run: true, exitOnError: true });
   }
   handleUsageError(err) {
-    const isClappError = !!err && typeof err === "object" && err.name === "ClappError";
-    const isUsage = isClappError && err.isUsageError !== false;
-    if (!isUsage)
+    if (!isClappError(err) || err.isUsageError === false)
       return;
-    const e2 = err;
-    const raw2 = e2.message ?? "command-line error";
+    const raw2 = err.message || "command-line error";
     const label = this.name ? `${this.name}: ` : "";
-    const suffix = /--help/.test(raw2) ? "" : `
+    const suffix = /--help/.test(raw2) ? "" : err.usage ? `
+Usage: ${err.usage}` : `
 Run \`${this.name ?? "cli"} --help\` for usage.`;
     process52.stderr.write(`${label}${raw2}${suffix}
 `);
-    process52.exit(e2.exitCode ?? 2);
+    process52.exit(err.exitCode ?? 2);
   }
   async runMatchedCommand() {
     const { args, options, matchedCommand: command } = this;
@@ -31690,7 +31874,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.2.25";
+var version2 = "0.2.27";
 
 // bin/cli.ts
 init_actions();