@open-mercato/core 0.5.1-develop.2691.d8a0934b37 → 0.5.1-develop.2694.732417c5ec

package/dist/modules/query_index/lib/engine.js

@@ -1,5 +1,6 @@
 import { SortDir } from "@open-mercato/shared/lib/query/types";
 import { resolveEntityTableName } from "@open-mercato/shared/lib/query/engine";
+import { sql } from "kysely";
 import { readCoverageSnapshot, refreshCoverageSnapshot } from "./coverage.js";
 import { createProfiler, shouldEnableProfiler } from "@open-mercato/shared/lib/profiler";
 import { decryptIndexDocCustomFields } from "@open-mercato/shared/lib/encryption/indexDoc";
@@ -82,6 +83,11 @@ class HybridQueryEngine {
       return null;
     }
   }
+  getDb() {
+    const emAny = this.em;
+    if (typeof emAny.getKysely === "function") return emAny.getKysely();
+    throw new Error("HybridQueryEngine requires an EntityManager exposing getKysely() (MikroORM v7)");
+  }
   async query(entity, opts = {}) {
     const ext = opts.extensions;
     let hybridExtCtx = null;
@@ -148,8 +154,8 @@ class HybridQueryEngine {
           throw err;
         }
       }
-      const knex = this.getKnex();
-      profiler.mark("query:knex_ready");
+      const db = this.getDb();
+      profiler.mark("query:db_ready");
       const baseTable = resolveEntityTableName(this.em, entity);
       profiler.mark("query:base_table_resolved");
       const searchConfig = resolveSearchConfig();
@@ -261,10 +267,11 @@ class HybridQueryEngine {
         }
       }
       const qualify = (col) => `b.${col}`;
-      let builder = knex({ b: baseTable });
-      const hasCustomFieldFilters = cfFilters.length > 0;
-      const canOptimizeCount = !hasCustomFieldFilters;
-      let optimizedCountBuilder = canOptimizeCount ? knex({ b: baseTable }) : null;
+      const columns = await this.getBaseColumnsForEntity(entity);
+      const hasOrganizationColumn = await this.columnExists(baseTable, "organization_id");
+      const hasTenantColumn = await this.columnExists(baseTable, "tenant_id");
+      const hasDeletedColumn = await this.columnExists(baseTable, "deleted_at");
+      if (!opts.tenantId) throw new Error("QueryEngine: tenantId is required");
       const resolvedJoinsConfig = resolveJoins(
         baseTable,
         [...opts.joins ?? [], ...buildFilterableCustomFieldJoins(opts.customFieldSources)],
@@ -280,76 +287,22 @@ class HybridQueryEngine {
         aliasTables.set(join.alias, join.table);
       }
       const { baseFilters, joinFilters } = partitionFilters(baseTable, normalizedFilters, joinMap);
-      if (!opts.tenantId) throw new Error("QueryEngine: tenantId is required");
-      const hasOrganizationColumn = await this.columnExists(baseTable, "organization_id");
-      const hasTenantColumn = await this.columnExists(baseTable, "tenant_id");
-      const hasDeletedColumn = await this.columnExists(baseTable, "deleted_at");
       const searchRuntimeBase = {
         enabled: false,
         config: searchConfig,
         organizationScope: orgScope,
         tenantId: opts.tenantId ?? null
       };
-      if (orgScope && hasOrganizationColumn) {
-        builder = this.applyOrganizationScope(builder, qualify("organization_id"), orgScope);
-        if (optimizedCountBuilder) optimizedCountBuilder = this.applyOrganizationScope(optimizedCountBuilder, qualify("organization_id"), orgScope);
-      }
-      if (hasTenantColumn) {
-        builder = builder.where(qualify("tenant_id"), opts.tenantId);
-        if (optimizedCountBuilder) optimizedCountBuilder = optimizedCountBuilder.where(qualify("tenant_id"), opts.tenantId);
-      }
-      if (!opts.withDeleted && hasDeletedColumn) {
-        builder = builder.whereNull(qualify("deleted_at"));
-        if (optimizedCountBuilder) optimizedCountBuilder = optimizedCountBuilder.whereNull(qualify("deleted_at"));
-      }
-      const baseJoinParts = [];
-      baseJoinParts.push(`ei.entity_type = ${knex.raw("?", [entity]).toString()}`);
-      baseJoinParts.push(`ei.entity_id = (${qualify("id")}::text)`);
-      if (hasOrganizationColumn) {
-        baseJoinParts.push(`ei.organization_id = ${qualify("organization_id")}`);
-        baseJoinParts.push("ei.organization_id is not null");
-      }
-      if (hasTenantColumn) {
-        baseJoinParts.push(`ei.tenant_id = ${qualify("tenant_id")}`);
-        baseJoinParts.push("ei.tenant_id is not null");
-      }
-      if (!opts.withDeleted) baseJoinParts.push(`ei.deleted_at is null`);
-      builder = builder.leftJoin({ ei: "entity_indexes" }, knex.raw(baseJoinParts.join(" AND ")));
-      const columns = await this.getBaseColumnsForEntity(entity);
       const indexSources = [{ alias: "ei", entityId: entity, recordIdColumn: "b.id" }];
+      let preparedCfSources = [];
       const shouldAttachCustomSources = Array.isArray(opts.customFieldSources) && opts.customFieldSources.length > 0 && (wantsCf || searchEnabled);
       if (shouldAttachCustomSources) {
-        const prepared = this.prepareCustomFieldSources(knex, builder, opts.customFieldSources ?? [], qualify);
-        builder = prepared.builder;
-        for (const source of prepared.sources) {
-          const fragments = [];
-          fragments.push(`${source.indexAlias}.entity_type = ${knex.raw("?", [source.entityId]).toString()}`);
-          fragments.push(`${source.indexAlias}.entity_id = (${knex.raw("??::text", [`${source.alias}.${source.recordIdColumn}`]).toString()})`);
-          const orgExpr = source.organizationField ? knex.raw("??", [`${source.alias}.${source.organizationField}`]).toString() : columns.has("organization_id") ? qualify("organization_id") : null;
-          if (orgExpr) {
-            fragments.push(`${source.indexAlias}.organization_id = ${orgExpr}`);
-            fragments.push(`${source.indexAlias}.organization_id is not null`);
-          }
-          const tenantExpr = source.tenantField ? knex.raw("??", [`${source.alias}.${source.tenantField}`]).toString() : columns.has("tenant_id") ? qualify("tenant_id") : null;
-          if (tenantExpr) {
-            fragments.push(`${source.indexAlias}.tenant_id = ${tenantExpr}`);
-            fragments.push(`${source.indexAlias}.tenant_id is not null`);
-          }
-          if (!opts.withDeleted) fragments.push(`${source.indexAlias}.deleted_at is null`);
-          builder = builder.leftJoin({ [source.indexAlias]: "entity_indexes" }, knex.raw(fragments.join(" AND ")));
+        preparedCfSources = this.prepareCustomFieldSources(opts.customFieldSources ?? []);
+        for (const source of preparedCfSources) {
           indexSources.push({ alias: source.indexAlias, entityId: source.entityId, recordIdColumn: `${source.alias}.${source.recordIdColumn}` });
         }
       }
-      if (debugEnabled) {
-        this.debug("query:index-sources", {
-          entity,
-          sources: indexSources.map((src) => ({ alias: src.alias, entity: src.entityId }))
-        });
-      }
-      const searchSources = indexSources.map((src) => ({
-        entity: String(src.entityId),
-        recordIdColumn: src.recordIdColumn
-      })).filter((src) => src.recordIdColumn && src.entity);
+      const searchSources = indexSources.map((src) => ({ entity: String(src.entityId), recordIdColumn: src.recordIdColumn })).filter((src) => src.recordIdColumn && src.entity);
       const hasSearchTokens = searchEnabled && searchSources.length ? await this.searchSourcesHaveTokens(searchSources, opts.tenantId ?? null, orgScope) : false;
       const searchRuntime = { ...searchRuntimeBase, searchSources, enabled: searchEnabled && hasSearchTokens };
       const joinSearchAvailability = /* @__PURE__ */ new Map();
@@ -372,24 +325,18 @@ class HybridQueryEngine {
             blocklistedFields: searchConfig.blocklistedFields
           }
         });
-        if (!searchEnabled) {
-          this.logSearchDebug("search:disabled", { entity, baseTable });
-        } else if (!hasSearchTokens) {
-          this.logSearchDebug("search:no-search-tokens", {
-            entity,
-            baseTable,
-            tenantId: opts.tenantId ?? null,
-            organizationScope: orgScope,
-            searchSources
-          });
-        }
+        if (!searchEnabled) this.logSearchDebug("search:disabled", { entity, baseTable });
+        else if (!hasSearchTokens) this.logSearchDebug("search:no-search-tokens", {
+          entity,
+          baseTable,
+          tenantId: opts.tenantId ?? null,
+          organizationScope: orgScope,
+          searchSources
+        });
       }
       const hasNonBaseSearchSource = searchSources.some(
         (src) => src.entity !== String(entity) || src.recordIdColumn !== "b.id"
       );
-      if (hasNonBaseSearchSource) {
-        optimizedCountBuilder = null;
-      }
       if (!partialIndexWarning && Array.isArray(opts.customFieldSources) && opts.customFieldSources.length > 0 && this.isForcePartialIndexEnabled()) {
         const seen = /* @__PURE__ */ new Set([entity]);
         for (const source of opts.customFieldSources) {
@@ -444,14 +391,7 @@ class HybridQueryEngine {
             const globalGap = globalBase > 0 && globalIndexed < globalBase || globalIndexed > globalBase;
             if (globalGap) {
               console.warn("[HybridQueryEngine] Partial index coverage detected at global scope; forcing query index usage due to FORCE_QUERY_INDEX_ON_PARTIAL_INDEXES:", { entity, baseCount: globalBase, indexedCount: globalIndexed, scope: "global" });
-              if (debugEnabled) {
-                this.debug("query:partial-coverage:forced", {
-                  entity,
-                  baseCount: globalBase,
-                  indexedCount: globalIndexed,
-                  scope: "global"
-                });
-              }
+              if (debugEnabled) this.debug("query:partial-coverage:forced", { entity, baseCount: globalBase, indexedCount: globalIndexed, scope: "global" });
               partialIndexWarning = {
                 entity,
                 entityLabel: this.resolveEntityLabel(entity),
@@ -462,12 +402,7 @@ class HybridQueryEngine {
             }
           }
         } catch (err) {
-          if (debugEnabled) {
-            this.debug("query:partial-coverage:global-check-failed", {
-              entity,
-              error: err instanceof Error ? err.message : err
-            });
-          }
+          if (debugEnabled) this.debug("query:partial-coverage:global-check-failed", { entity, error: err instanceof Error ? err.message : err });
         }
       }
       const resolveBaseColumn = (field) => {
@@ -475,38 +410,81 @@ class HybridQueryEngine {
         if (field === "organization_id" && columns.has("id")) return "id";
         return null;
       };
-      for (const filter of cfFilters) {
-        builder = this.applyCfFilterAcrossSources(
-          knex,
-          builder,
-          filter.field,
-          filter.op,
-          filter.value,
-          indexSources,
-          searchRuntime
-        );
-      }
-      const regularBaseFilters = baseFilters.filter((filter) => !filter.orGroup);
-      const orGroupFilters = baseFilters.filter((filter) => filter.orGroup);
-      for (const filter of regularBaseFilters) {
-        const fieldName = String(filter.field);
-        const baseField = resolveBaseColumn(fieldName);
-        if (!baseField) {
-          builder = this.applyIndexDocFilterFromAlias(
-            knex,
-            builder,
-            "ei",
-            entity,
-            fieldName,
+      const applyBaseScope = (q) => {
+        let next = q;
+        if (orgScope && hasOrganizationColumn) {
+          next = this.applyOrganizationScope(next, qualify("organization_id"), orgScope);
+        }
+        if (hasTenantColumn) {
+          next = next.where(qualify("tenant_id"), "=", opts.tenantId);
+        }
+        if (!opts.withDeleted && hasDeletedColumn) {
+          next = next.where(qualify("deleted_at"), "is", null);
+        }
+        return next;
+      };
+      const applyEntityIndexesJoin = (q) => {
+        return q.leftJoin("entity_indexes as ei", (jb) => {
+          let jc = jb.on("ei.entity_type", "=", String(entity)).onRef("ei.entity_id", "=", sql`(${sql.ref(qualify("id"))}::text)`);
+          if (hasOrganizationColumn) {
+            jc = jc.onRef("ei.organization_id", "=", qualify("organization_id")).on("ei.organization_id", "is not", null);
+          }
+          if (hasTenantColumn) {
+            jc = jc.onRef("ei.tenant_id", "=", qualify("tenant_id")).on("ei.tenant_id", "is not", null);
+          }
+          if (!opts.withDeleted) {
+            jc = jc.on("ei.deleted_at", "is", null);
+          }
+          return jc;
+        });
+      };
+      const applyCustomFieldSourceJoins = (q) => {
+        let next = q;
+        for (const source of preparedCfSources) {
+          const join = (opts.customFieldSources ?? []).find((s) => s && (s.alias ?? void 0) === source.alias)?.join;
+          if (!join) continue;
+          const joinType = (join.type ?? "left") === "inner" ? "innerJoin" : "leftJoin";
+          next = next[joinType](`${source.table} as ${source.alias}`, (jb) => jb.onRef(`${source.alias}.${join.toField}`, "=", qualify(join.fromField)));
+          next = next.leftJoin(`entity_indexes as ${source.indexAlias}`, (jb) => {
+            let jc = jb.on(`${source.indexAlias}.entity_type`, "=", String(source.entityId)).onRef(`${source.indexAlias}.entity_id`, "=", sql`(${sql.ref(`${source.alias}.${source.recordIdColumn}`)}::text)`);
+            const orgRef = source.organizationField ? `${source.alias}.${source.organizationField}` : columns.has("organization_id") ? qualify("organization_id") : null;
+            if (orgRef) {
+              jc = jc.onRef(`${source.indexAlias}.organization_id`, "=", orgRef).on(`${source.indexAlias}.organization_id`, "is not", null);
+            }
+            const tenantRef = source.tenantField ? `${source.alias}.${source.tenantField}` : columns.has("tenant_id") ? qualify("tenant_id") : null;
+            if (tenantRef) {
+              jc = jc.onRef(`${source.indexAlias}.tenant_id`, "=", tenantRef).on(`${source.indexAlias}.tenant_id`, "is not", null);
+            }
+            if (!opts.withDeleted) jc = jc.on(`${source.indexAlias}.deleted_at`, "is", null);
+            return jc;
+          });
+        }
+        return next;
+      };
+      const applyCfFilters = (q) => {
+        let next = q;
+        for (const filter of cfFilters) {
+          next = this.applyCfFilterAcrossSources(
+            next,
+            filter.field,
             filter.op,
             filter.value,
-            "b.id",
+            indexSources,
             searchRuntime
           );
-          if (optimizedCountBuilder) {
-            optimizedCountBuilder = this.applyIndexDocFilterFromAlias(
-              knex,
-              optimizedCountBuilder,
+        }
+        return next;
+      };
+      const regularBaseFilters = baseFilters.filter((filter) => !filter.orGroup);
+      const orGroupFilters = baseFilters.filter((filter) => filter.orGroup);
+      const applyRegularBaseFilters = (q) => {
+        let next = q;
+        for (const filter of regularBaseFilters) {
+          const fieldName = String(filter.field);
+          const baseField = resolveBaseColumn(fieldName);
+          if (!baseField) {
+            next = this.applyIndexDocFilterFromAlias(
+              next,
               "ei",
               entity,
               fieldName,
@@ -515,29 +493,20 @@ class HybridQueryEngine {
               "b.id",
               searchRuntime
             );
+            continue;
           }
-          continue;
-        }
-        const column = qualify(baseField);
-        builder = this.applyColumnFilter(builder, column, filter, {
-          ...searchRuntime,
-          knex,
-          entity,
-          field: fieldName,
-          recordIdColumn: "b.id"
-        });
-        if (optimizedCountBuilder) {
-          optimizedCountBuilder = this.applyColumnFilter(optimizedCountBuilder, column, filter, {
+          const column = qualify(baseField);
+          next = this.applyColumnFilter(next, column, filter, {
             ...searchRuntime,
-            knex,
             entity,
             field: fieldName,
             recordIdColumn: "b.id"
           });
         }
-      }
-      const applyOrGroupedBaseFilters = (target) => {
-        if (!target || orGroupFilters.length === 0) return target;
+        return next;
+      };
+      const applyOrGroupedBaseFilters = (q) => {
+        if (orGroupFilters.length === 0) return q;
         const groups = /* @__PURE__ */ new Map();
         for (const filter of orGroupFilters) {
           if (!filter.orGroup) continue;
@@ -545,99 +514,61 @@ class HybridQueryEngine {
           existing.push(filter);
           groups.set(filter.orGroup, existing);
         }
-        let next = target;
+        let next = q;
         for (const [, groupFilters] of groups) {
           if (!groupFilters.length) continue;
-          next = next.where((groupBuilder) => {
-            groupFilters.forEach((filter, index) => {
-              const fieldName = String(filter.field);
-              const baseField = resolveBaseColumn(fieldName);
-              const applyCondition = (conditionBuilder) => {
-                if (!baseField) {
-                  this.applyIndexDocFilterFromAlias(
-                    knex,
-                    conditionBuilder,
-                    "ei",
-                    entity,
-                    fieldName,
-                    filter.op,
-                    filter.value,
-                    "b.id",
-                    searchRuntime
-                  );
-                  return;
-                }
-                this.applyColumnFilter(conditionBuilder, qualify(baseField), filter, {
-                  ...searchRuntime,
-                  knex,
-                  entity,
-                  field: fieldName,
-                  recordIdColumn: "b.id"
-                });
-              };
-              if (index === 0) {
-                applyCondition(groupBuilder);
-                return;
-              }
-              groupBuilder.orWhere((conditionBuilder) => {
-                applyCondition(conditionBuilder);
-              });
-            });
-          });
+          next = next.where((eb) => eb.or(
+            groupFilters.map((filter) => this.buildBaseFilterExpression(eb, filter, resolveBaseColumn, qualify, entity, searchRuntime))
+          ));
         }
         return next;
       };
-      builder = applyOrGroupedBaseFilters(builder) ?? builder;
-      optimizedCountBuilder = applyOrGroupedBaseFilters(optimizedCountBuilder);
       const applyAliasScopes = async (target, aliasName) => {
+        let next = target;
         const tableName = aliasTables.get(aliasName);
-        if (!tableName) return;
+        if (!tableName) return next;
         if (orgScope && await this.columnExists(tableName, "organization_id")) {
-          this.applyOrganizationScope(target, `${aliasName}.organization_id`, orgScope);
+          next = this.applyOrganizationScope(next, `${aliasName}.organization_id`, orgScope);
         }
         if (opts.tenantId && await this.columnExists(tableName, "tenant_id")) {
-          target.where(`${aliasName}.tenant_id`, opts.tenantId);
+          next = next.where(`${aliasName}.tenant_id`, "=", opts.tenantId);
         }
         if (!opts.withDeleted && await this.columnExists(tableName, "deleted_at")) {
-          target.whereNull(`${aliasName}.deleted_at`);
+          next = next.where(`${aliasName}.deleted_at`, "is", null);
         }
+        return next;
       };
-      const applyJoinFilterOp = (target, column, op, value) => {
+      const applyJoinFilterOpFn = (target, column, op, value) => {
         switch (op) {
           case "eq":
-            target.where(column, value);
-            break;
+            return target.where(column, "=", value);
           case "ne":
-            target.whereNot(column, value);
-            break;
+            return target.where(column, "!=", value);
           case "gt":
+            return target.where(column, ">", value);
           case "gte":
+            return target.where(column, ">=", value);
           case "lt":
-          case "lte": {
-            const operator = op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=";
-            target.where(column, operator, value);
-            break;
-          }
+            return target.where(column, "<", value);
+          case "lte":
+            return target.where(column, "<=", value);
           case "in":
-            target.whereIn(column, this.toArray(value));
-            break;
+            return target.where(column, "in", this.toArray(value));
           case "nin":
-            target.whereNotIn(column, this.toArray(value));
-            break;
+            return target.where(column, "not in", this.toArray(value));
           case "like":
-            target.where(column, "like", value);
-            break;
+            return target.where(column, "like", value);
           case "ilike":
-            target.where(column, "ilike", value);
-            break;
+            return target.where(column, "ilike", value);
           case "exists":
-            value ? target.whereNotNull(column) : target.whereNull(column);
-            break;
+            return value ? target.where(column, "is not", null) : target.where(column, "is", null);
+          default:
+            return target;
         }
       };
       const applyJoinSearchFilterOp = async (target, filter, _qualified, join) => {
         if (!searchEnabled || !join.entityId) return false;
-        if (!["eq", "like", "ilike"].includes(filter.op)) return false;
+        if (!["like", "ilike"].includes(filter.op)) return false;
         if (typeof filter.value !== "string" || filter.value.trim().length === 0) return false;
         let searchAvailable = joinSearchAvailability.get(join.entityId);
         if (searchAvailable === void 0) {
@@ -648,7 +579,6 @@ class HybridQueryEngine {
         const tokens = tokenizeText(String(filter.value), searchConfig);
         if (!tokens.hashes.length) return false;
         return this.applySearchTokens(target, {
-          knex,
           entity: String(join.entityId),
           field: filter.column,
           hashes: tokens.hashes,
@@ -657,43 +587,40 @@ class HybridQueryEngine {
           organizationScope: orgScope
         });
       };
-      await applyJoinFilters({
-        knex,
-        baseTable,
-        builder,
-        joinMap,
-        joinFilters,
-        aliasTables,
-        qualifyBase: (column) => qualify(column),
-        applyAliasScope: (target, alias) => applyAliasScopes(target, alias),
-        applyFilterOp: (target, column, op, value) => applyJoinFilterOp(target, column, op, value),
-        applyJoinFilterOp: (target, filter, qualified, join) => applyJoinSearchFilterOp(target, filter, qualified, join),
-        columnExists: (tbl, column) => this.columnExists(tbl, column)
-      });
-      if (optimizedCountBuilder) {
-        await applyJoinFilters({
-          knex,
+      const applyQueryShape = async (q) => {
+        let next = applyBaseScope(q);
+        next = applyEntityIndexesJoin(next);
+        next = applyCustomFieldSourceJoins(next);
+        next = applyCfFilters(next);
+        next = applyRegularBaseFilters(next);
+        next = applyOrGroupedBaseFilters(next);
+        next = await applyJoinFilters({
+          db,
           baseTable,
-          builder: optimizedCountBuilder,
+          builder: next,
           joinMap,
           joinFilters,
           aliasTables,
           qualifyBase: (column) => qualify(column),
-          applyAliasScope: (target, alias) => applyAliasScopes(target, alias),
-          applyFilterOp: (target, column, op, value) => applyJoinFilterOp(target, column, op, value),
-          applyJoinFilterOp: (target, filter, qualified, join) => applyJoinSearchFilterOp(target, filter, qualified, join),
+          applyAliasScope: async (target, alias) => applyAliasScopes(target, alias),
+          applyFilterOp: (target, column, op, value) => applyJoinFilterOpFn(target, column, op, value),
+          applyJoinFilterOp: async (target, filter, qualified, join) => {
+            const applied = await applyJoinSearchFilterOp(target, filter, qualified, join);
+            return { applied, builder: target };
+          },
           columnExists: (tbl, column) => this.columnExists(tbl, column)
         });
-      }
+        return next;
+      };
+      const hasCustomFieldFilters = cfFilters.length > 0;
+      const canOptimizeCount = !hasCustomFieldFilters && !hasNonBaseSearchSource;
       const selectFieldSet = new Set(opts.fields && opts.fields.length ? opts.fields.map(String) : Array.from(columns.keys()));
       if (opts.includeCustomFields === true) {
         const entityIds = Array.from(new Set(indexSources.map((src) => String(src.entityId))));
         try {
           const resolvedKeys = await this.resolveAvailableCustomFieldKeys(entityIds, opts.tenantId ?? null);
           resolvedKeys.forEach((key) => selectFieldSet.add(`cf:${key}`));
-          if (this.isDebugVerbosity()) {
-            this.debug("query:cf:resolved-keys", { entity, keys: resolvedKeys });
-          }
+          if (this.isDebugVerbosity()) this.debug("query:cf:resolved-keys", { entity, keys: resolvedKeys });
         } catch (err) {
           console.warn("[HybridQueryEngine] Failed to resolve custom field keys for", entity, err);
         }
@@ -701,74 +628,107 @@ class HybridQueryEngine {
         opts.includeCustomFields.map((key) => String(key)).forEach((key) => selectFieldSet.add(`cf:${key}`));
       }
       const selectFields = Array.from(selectFieldSet);
-      for (const field of selectFields) {
-        const fieldName = String(field);
-        if (fieldName.startsWith("cf:")) {
-          const alias = this.sanitize(fieldName);
-          const { jsonSql } = this.buildCfExpressions(knex, fieldName, indexSources);
-          const exprSql = jsonSql === "NULL" ? "NULL::jsonb" : jsonSql;
-          builder = builder.select(knex.raw(`${exprSql} as ??`, [alias]));
-        } else if (columns.has(fieldName)) {
-          builder = builder.select(knex.raw("?? as ??", [qualify(fieldName), fieldName]));
+      const applySelection = (q) => {
+        let next = q;
+        for (const field of selectFields) {
+          const fieldName = String(field);
+          if (fieldName.startsWith("cf:")) {
+            const alias = this.sanitize(fieldName);
+            const jsonExpr = this.buildCfJsonExprSql(fieldName, indexSources);
+            const exprRaw = jsonExpr ?? sql`NULL::jsonb`;
+            next = next.select(exprRaw.as(alias));
+          } else if (columns.has(fieldName)) {
+            next = next.select(`${qualify(fieldName)} as ${fieldName}`);
+          }
         }
-      }
-      for (const sort of opts.sort || []) {
-        const fieldName = String(sort.field);
-        if (fieldName.startsWith("cf:")) {
-          const { textSql } = this.buildCfExpressions(knex, fieldName, indexSources);
-          if (textSql !== "NULL") {
-            const direction = sort.dir ?? SortDir.Asc;
-            builder = builder.orderByRaw(`${textSql} ${direction}`);
+        return next;
+      };
+      const applySort = (q) => {
+        let next = q;
+        for (const s of opts.sort || []) {
+          const fieldName = String(s.field);
+          if (fieldName.startsWith("cf:")) {
+            const textExpr = this.buildCfTextExprSql(fieldName, indexSources);
+            if (textExpr) {
+              const direction = sql.raw(String(s.dir ?? SortDir.Asc));
+              next = next.orderBy(sql`${textExpr} ${direction}`);
+            }
+          } else {
+            const baseField = resolveBaseColumn(fieldName);
+            if (!baseField) continue;
+            next = next.orderBy(qualify(baseField), s.dir ?? SortDir.Asc);
           }
-        } else {
-          const baseField = resolveBaseColumn(fieldName);
-          if (!baseField) continue;
-          builder = builder.orderBy(qualify(baseField), sort.dir ?? SortDir.Asc);
         }
-      }
+        return next;
+      };
       const page = opts.page?.page ?? 1;
       const pageSize = opts.page?.pageSize ?? 20;
       const sqlDebugEnabled = this.isSqlDebugEnabled();
       let total;
-      if (optimizedCountBuilder) {
-        const countSource = optimizedCountBuilder.clone().clearSelect().clearOrder().select(knex.raw(`${qualify("id")} as id`)).groupBy(qualify("id"));
-        const countQuery = knex.from(countSource.as("sq")).count({ count: knex.raw("*") });
+      if (canOptimizeCount) {
+        const optimizedRoot = db.selectFrom(`${baseTable} as b`);
+        let countCore = applyBaseScope(optimizedRoot);
+        countCore = applyRegularBaseFilters(countCore);
+        countCore = applyOrGroupedBaseFilters(countCore);
+        countCore = await applyJoinFilters({
+          db,
+          baseTable,
+          builder: countCore,
+          joinMap,
+          joinFilters,
+          aliasTables,
+          qualifyBase: (column) => qualify(column),
+          applyAliasScope: async (target, alias) => applyAliasScopes(target, alias),
+          applyFilterOp: (target, column, op, value) => applyJoinFilterOpFn(target, column, op, value),
+          applyJoinFilterOp: async (target, filter, qualified, join) => {
+            const applied = await applyJoinSearchFilterOp(target, filter, qualified, join);
+            return { applied, builder: target };
+          },
+          columnExists: (tbl, column) => this.columnExists(tbl, column)
+        });
+        const sub = countCore.select(sql.ref(qualify("id")).as("id")).groupBy(qualify("id")).as("sq");
+        const countQuery = db.selectFrom(sub).select(sql`count(*)`.as("count"));
         if (debugEnabled && sqlDebugEnabled) {
-          const { sql, bindings } = countQuery.clone().toSQL();
-          this.debug("query:sql:count", { entity, sql, bindings });
+          const compiled = countQuery.compile();
+          this.debug("query:sql:count", { entity, sql: compiled.sql, bindings: compiled.parameters });
         }
         const countRow = await this.captureSqlTiming(
           "query:sql:count",
           entity,
-          () => countQuery.first(),
+          () => countQuery.executeTakeFirst(),
           { optimized: true },
           profiler
         );
         total = this.parseCount(countRow);
       } else {
-        const countBuilder = builder.clone().clearSelect().clearOrder().countDistinct(`${qualify("id")} as count`);
+        const countRoot = db.selectFrom(`${baseTable} as b`);
+        const countBuilder = (await applyQueryShape(countRoot)).select(sql`count(distinct ${sql.ref(qualify("id"))})`.as("count"));
         if (debugEnabled && sqlDebugEnabled) {
-          const { sql, bindings } = countBuilder.clone().toSQL();
-          this.debug("query:sql:count", { entity, sql, bindings });
+          const compiled = countBuilder.compile();
+          this.debug("query:sql:count", { entity, sql: compiled.sql, bindings: compiled.parameters });
         }
         const countRow = await this.captureSqlTiming(
           "query:sql:count",
           entity,
-          () => countBuilder.first(),
+          () => countBuilder.executeTakeFirst(),
           { optimized: false },
           profiler
         );
         total = this.parseCount(countRow);
       }
-      const dataBuilder = builder.clone().limit(pageSize).offset((page - 1) * pageSize);
+      const dataRoot = db.selectFrom(`${baseTable} as b`);
+      let dataBuilder = await applyQueryShape(dataRoot);
+      dataBuilder = applySelection(dataBuilder);
+      dataBuilder = applySort(dataBuilder);
+      dataBuilder = dataBuilder.limit(pageSize).offset((page - 1) * pageSize);
       if (debugEnabled && sqlDebugEnabled) {
-        const { sql, bindings } = dataBuilder.clone().toSQL();
-        this.debug("query:sql:data", { entity, sql, bindings, page, pageSize });
+        const compiled = dataBuilder.compile();
+        this.debug("query:sql:data", { entity, sql: compiled.sql, bindings: compiled.parameters, page, pageSize });
       }
       const itemsRaw = await this.captureSqlTiming(
         "query:sql:data",
         entity,
-        () => dataBuilder,
+        () => dataBuilder.execute(),
         { page, pageSize },
         profiler
       );
@@ -816,9 +776,7 @@ class HybridQueryEngine {
       }
       const typedItems = items;
       let result = { items: typedItems, page, pageSize, total };
-      if (partialIndexWarning) {
-        result.meta = { partialIndexWarning };
-      }
+      if (partialIndexWarning) result.meta = { partialIndexWarning };
       result = await applyAfterExtensions(result);
       finishProfile({
         result: "ok",
@@ -834,30 +792,15 @@ class HybridQueryEngine {
       throw err;
     }
   }
-  getKnex() {
-    const connection = this.em.getConnection();
-    const withKnex = connection;
-    if (typeof withKnex.getKnex === "function") {
-      return withKnex.getKnex();
-    }
-    throw new Error("HybridQueryEngine requires a SQL connection that exposes getKnex()");
-  }
-  prepareCustomFieldSources(knex, builder, sources, qualify) {
-    let current = builder;
+  prepareCustomFieldSources(sources) {
     const prepared = [];
     sources.forEach((source, index) => {
       if (!source) return;
       const joinTable = source.table ?? resolveEntityTableName(this.em, source.entityId);
       const alias = source.alias ?? `cfs_${index}`;
-      const join = source.join;
-      if (!join) {
+      if (!source.join) {
         throw new Error(`QueryEngine: customFieldSources entry for ${String(source.entityId)} requires a join configuration`);
       }
-      const joinArgs = { [alias]: joinTable };
-      const joinCallback = function() {
-        this.on(`${alias}.${join.toField}`, "=", qualify(join.fromField));
-      };
-      current = (join.type ?? "left") === "inner" ? current.join(joinArgs, joinCallback) : current.leftJoin(joinArgs, joinCallback);
       prepared.push({
         alias,
         indexAlias: `ei_${alias}`,
@@ -868,17 +811,26 @@ class HybridQueryEngine {
         table: joinTable
       });
     });
-    return { builder: current, sources: prepared };
+    return prepared;
   }
   async isCustomEntity(entity) {
     try {
-      const knex = this.getKnex();
-      const row = await knex("custom_entities").where({ entity_id: entity, is_active: true }).first();
+      const db = this.getDb();
+      const row = await db.selectFrom("custom_entities").select("id").where("entity_id", "=", entity).where("is_active", "=", true).executeTakeFirst();
       return !!row;
     } catch {
       return false;
     }
   }
+  /**
+   * Adds a WHERE EXISTS / OR WHERE EXISTS subquery that matches
+   * `search_tokens` for the supplied (entity, field) against the
+   * provided record id column.
+   *
+   * Returns true when the sub-query was applied (i.e. tokens were
+   * non-empty). Caller is responsible for the calling context
+   * (direct where vs. inside `eb.or([...])`).
+   */
   applySearchTokens(q, opts) {
     if (!opts.hashes.length) {
       this.logSearchDebug("search:skip-no-hashes", {
@@ -890,8 +842,6 @@ class HybridQueryEngine {
       return false;
     }
     const alias = `st_${this.searchAliasSeq++}`;
-    const combineWith = opts.combineWith === "or" ? "orWhereExists" : "whereExists";
-    const engine = this;
     this.logSearchDebug("search:apply-search-tokens", {
       entity: opts.entity,
       field: opts.field,
@@ -901,63 +851,67 @@ class HybridQueryEngine {
       organizationScope: opts.organizationScope,
       combineWith: opts.combineWith ?? "and"
     });
-    q[combineWith](function() {
-      this.select(1).from({ [alias]: "search_tokens" }).where(`${alias}.entity_type`, opts.entity).andWhere(`${alias}.field`, opts.field).andWhereRaw("?? = ??::text", [`${alias}.entity_id`, opts.recordIdColumn]).whereIn(`${alias}.token_hash`, opts.hashes).groupBy(`${alias}.entity_id`, `${alias}.field`).havingRaw(`count(distinct ${alias}.token_hash) >= ?`, [opts.hashes.length]);
+    const engine = this;
+    const buildSub = (eb) => {
+      let sub = eb.selectFrom(`search_tokens as ${alias}`).select(sql`1`.as("one")).where(`${alias}.entity_type`, "=", opts.entity).where(`${alias}.field`, "=", opts.field).where(sql`${sql.ref(`${alias}.entity_id`)} = ${sql.ref(opts.recordIdColumn)}::text`).where(`${alias}.token_hash`, "in", opts.hashes).groupBy([`${alias}.entity_id`, `${alias}.field`]).having(sql`count(distinct ${sql.ref(`${alias}.token_hash`)}) >= ${opts.hashes.length}`);
       if (opts.tenantId !== void 0) {
-        this.andWhereRaw(`${alias}.tenant_id is not distinct from ?`, [opts.tenantId ?? null]);
+        sub = sub.where(sql`${sql.ref(`${alias}.tenant_id`)} is not distinct from ${opts.tenantId ?? null}`);
       }
       if (opts.organizationScope) {
-        engine.applyOrganizationScope(this, `${alias}.organization_id`, opts.organizationScope);
+        sub = engine.applyOrganizationScope(sub, `${alias}.organization_id`, opts.organizationScope);
       }
-    });
+      return sub;
+    };
+    if (opts.combineWith === "or") {
+      ;
+      q.__pendingOrExists = buildSub(q);
+      return true;
+    }
+    ;
+    q.__applied = true;
+    const built = buildSub(q);
+    if (typeof q.where === "function") {
+      ;
+      q = q.where((eb) => eb.exists(built));
+    }
     return true;
   }
-  jsonbRawAlias(knex, alias, key) {
+  /** SQL fragment for `cf:<key>` (or legacy bare key) as JSON across a single alias. */
+  jsonbSqlAlias(alias, key) {
     if (key.startsWith("cf:")) {
       const bare = key.slice(3);
-      return knex.raw(`coalesce(${alias}.doc -> ?, ${alias}.doc -> ?)`, [key, bare]);
+      return sql`coalesce(${sql.ref(alias + ".doc")} -> ${key}, ${sql.ref(alias + ".doc")} -> ${bare})`;
     }
-    return knex.raw(`${alias}.doc -> ?`, [key]);
+    return sql`${sql.ref(alias + ".doc")} -> ${key}`;
   }
-  cfTextExprAlias(knex, alias, key) {
+  /** SQL fragment for `cf:<key>` (or legacy bare key) as text across a single alias. */
+  cfTextExprAlias(alias, key) {
     if (key.startsWith("cf:")) {
       const bare = key.slice(3);
-      return knex.raw(`coalesce((${alias}.doc ->> ?), (${alias}.doc ->> ?))`, [key, bare]);
+      return sql`coalesce((${sql.ref(alias + ".doc")} ->> ${key}), (${sql.ref(alias + ".doc")} ->> ${bare}))`;
     }
-    return knex.raw(`(${alias}.doc ->> ?)`, [key]);
+    return sql`(${sql.ref(alias + ".doc")} ->> ${key})`;
+  }
+  /** Build JSON/text SQL expressions across multiple index alias sources (coalesce over them). */
+  buildCfJsonExprSql(key, sources) {
+    if (!sources.length) return null;
+    const parts = sources.map((src) => this.jsonbSqlAlias(src.alias, key));
+    if (parts.length === 1) return parts[0];
+    return sql`coalesce(${sql.join(parts, sql`, `)})`;
   }
-  buildCfExpressions(knex, key, sources) {
-    if (!sources.length) return { jsonSql: "NULL", textSql: "NULL" };
-    const jsonFragments = sources.map((source) => this.jsonbRawAlias(knex, source.alias, key).toString());
-    const textFragments = sources.map((source) => this.cfTextExprAlias(knex, source.alias, key).toString());
-    const jsonSql = jsonFragments.length === 1 ? jsonFragments[0] : `coalesce(${jsonFragments.join(", ")})`;
-    const textSql = textFragments.length === 1 ? textFragments[0] : `coalesce(${textFragments.join(", ")})`;
-    return { jsonSql, textSql };
+  buildCfTextExprSql(key, sources) {
+    if (!sources.length) return null;
+    const parts = sources.map((src) => this.cfTextExprAlias(src.alias, key));
+    if (parts.length === 1) return parts[0];
+    return sql`coalesce(${sql.join(parts, sql`, `)})`;
   }
-  applyCfFilterAcrossSources(knex, builder, key, op, value, sources, search) {
+  applyCfFilterAcrossSources(builder, key, op, value, sources, search) {
     if (!sources.length) return builder;
     if ((op === "like" || op === "ilike") && search?.enabled && typeof value === "string") {
       const tokens = tokenizeText(String(value), search.config);
       const hashes = tokens.hashes;
       if (hashes.length) {
-        let applied = false;
-        if (sources.length) {
-          builder = builder.where((qb) => {
-            sources.forEach((source, idx) => {
-              const ok = this.applySearchTokens(qb, {
-                knex,
-                entity: source.entityId,
-                field: key,
-                hashes,
-                recordIdColumn: `${source.alias}.entity_id`,
-                tenantId: search.tenantId ?? null,
-                organizationScope: search.organizationScope ?? null,
-                combineWith: idx === 0 ? "and" : "or"
-              });
-              if (ok) applied = true;
-            });
-          });
-        }
+        const applied = this.applyMultiSourceSearchExists(builder, sources, key, hashes, search);
         this.logSearchDebug("search:cf-filter-across", {
           entity: sources.map((src) => src.entityId),
           field: key,
@@ -967,7 +921,7 @@ class HybridQueryEngine {
           tenantId: search.tenantId ?? null,
           organizationScope: search.organizationScope
         });
-        if (applied) return builder;
+        if (applied.builder !== builder) return applied.builder;
       } else {
         this.logSearchDebug("search:cf-skip-empty-hashes", {
           entity: sources.map((src) => src.entityId),
@@ -977,193 +931,282 @@ class HybridQueryEngine {
       }
       return builder;
     }
-    const { jsonSql, textSql } = this.buildCfExpressions(knex, key, sources);
-    if (jsonSql === "NULL" || textSql === "NULL") return builder;
-    const textExpr = knex.raw(textSql);
-    const arrContains = (val) => knex.raw(`${jsonSql} @> ?::jsonb`, [JSON.stringify([val])]);
+    const textExpr = this.buildCfTextExprSql(key, sources);
+    const jsonExpr = this.buildCfJsonExprSql(key, sources);
+    if (!textExpr || !jsonExpr) return builder;
+    const arrContains = (val) => sql`${jsonExpr} @> ${JSON.stringify([val])}::jsonb`;
     switch (op) {
       case "eq":
-        return builder.where((qb) => {
-          qb.orWhere(textExpr, "=", value);
-          qb.orWhere(arrContains(value));
-        });
+        return builder.where((eb) => eb.or([
+          sql`${textExpr} = ${value}`,
+          arrContains(value)
+        ]));
       case "ne":
-        return builder.whereNot(textExpr, "=", value);
+        return builder.where(sql`${textExpr} <> ${value}`);
       case "in": {
         const values = this.toArray(value);
-        return builder.where((qb) => {
-          values.forEach((val) => {
-            qb.orWhere(textExpr, "=", val);
-            qb.orWhere(arrContains(val));
-          });
-        });
+        return builder.where((eb) => eb.or(
+          values.flatMap((val) => [
+            sql`${textExpr} = ${val}`,
+            arrContains(val)
+          ])
+        ));
       }
       case "nin": {
         const values = this.toArray(value);
-        return builder.whereNotIn(textExpr, values);
+        return builder.where(sql`${textExpr} not in (${sql.join(values.map((v) => sql`${v}`), sql`, `)})`);
       }
       case "like":
-        return builder.where(textExpr, "like", value);
+        return builder.where(sql`${textExpr} like ${value}`);
       case "ilike":
-        return builder.where(textExpr, "ilike", value);
+        return builder.where(sql`${textExpr} ilike ${value}`);
       case "exists":
-        return value ? builder.whereRaw(`${textExpr.toString()} is not null`) : builder.whereRaw(`${textExpr.toString()} is null`);
+        return value ? builder.where(sql`${textExpr} is not null`) : builder.where(sql`${textExpr} is null`);
       case "gt":
       case "gte":
       case "lt":
       case "lte": {
-        const operator = op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=";
-        return builder.where(textExpr, operator, value);
+        const operator = sql.raw(op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=");
+        return builder.where(sql`${textExpr} ${operator} ${value}`);
       }
       default:
         return builder;
     }
   }
-  applyCfFilterFromAlias(knex, q, alias, entityType, key, op, value, search) {
-    const text = this.cfTextExprAlias(knex, alias, key);
-    const arrExpr = knex.raw(`(${alias}.doc -> ?)`, [key]);
-    const arrContains = (val) => knex.raw(`${arrExpr.toString()} @> ?::jsonb`, [JSON.stringify([val])]);
+  /** Apply a search-token EXISTS subquery across multiple sources (OR-joined). */
+  applyMultiSourceSearchExists(builder, sources, key, hashes, search) {
+    if (!sources.length || !hashes.length) return { builder, applied: false };
+    const next = builder.where((eb) => eb.or(
+      sources.map(
+        (source) => eb.exists(this.buildSearchTokensSub(eb, {
+          entity: String(source.entityId),
+          field: key,
+          hashes,
+          recordIdColumn: `${source.alias}.entity_id`,
+          tenantId: search.tenantId ?? null,
+          organizationScope: search.organizationScope ?? null
+        }))
+      )
+    ));
+    return { builder: next, applied: true };
+  }
+  /** Construct a search-token EXISTS subquery using the given ExpressionBuilder. */
+  buildSearchTokensSub(eb, opts) {
+    const alias = `st_${this.searchAliasSeq++}`;
+    let sub = eb.selectFrom(`search_tokens as ${alias}`).select(sql`1`.as("one")).where(`${alias}.entity_type`, "=", opts.entity).where(`${alias}.field`, "=", opts.field).where(sql`${sql.ref(`${alias}.entity_id`)} = ${sql.ref(opts.recordIdColumn)}::text`).where(`${alias}.token_hash`, "in", opts.hashes).groupBy([`${alias}.entity_id`, `${alias}.field`]).having(sql`count(distinct ${sql.ref(`${alias}.token_hash`)}) >= ${opts.hashes.length}`);
+    if (opts.tenantId !== void 0) {
+      sub = sub.where(sql`${sql.ref(`${alias}.tenant_id`)} is not distinct from ${opts.tenantId ?? null}`);
+    }
+    if (opts.organizationScope) {
+      sub = this.applyOrganizationScope(sub, `${alias}.organization_id`, opts.organizationScope);
+    }
+    return sub;
+  }
+  applyCfFilterFromAlias(q, alias, entityType, key, op, value, search) {
+    const textExpr = this.cfTextExprAlias(alias, key);
+    const arrExpr = sql`(${sql.ref(alias + ".doc")} -> ${key})`;
+    const arrContains = (val) => sql`${arrExpr} @> ${JSON.stringify([val])}::jsonb`;
     if ((op === "like" || op === "ilike") && search?.enabled && typeof value === "string") {
       const tokens = tokenizeText(String(value), search.config);
       const hashes = tokens.hashes;
       if (hashes.length) {
-        const applied = this.applySearchTokens(q, {
-          knex,
+        const applied = q.where((eb) => eb.exists(this.buildSearchTokensSub(eb, {
           entity: entityType,
           field: key,
           hashes,
           recordIdColumn: `${alias}.entity_id`,
           tenantId: search.tenantId ?? null,
           organizationScope: search.organizationScope ?? null
-        });
+        })));
         this.logSearchDebug("search:cf-filter", {
           entity: entityType,
           field: key,
           tokens: tokens.tokens,
           hashes,
-          applied,
+          applied: true,
           tenantId: search.tenantId ?? null,
           organizationScope: search.organizationScope
         });
-        if (applied) return q;
+        return applied;
       } else {
-        this.logSearchDebug("search:cf-skip-empty-hashes", {
-          entity: entityType,
-          field: key,
-          value
-        });
+        this.logSearchDebug("search:cf-skip-empty-hashes", { entity: entityType, field: key, value });
       }
       return q;
     }
     switch (op) {
       case "eq":
-        return q.where((builder) => {
-          builder.orWhere(text, "=", value);
-          builder.orWhere(arrContains(value));
-        });
+        return q.where((eb) => eb.or([
+          sql`${textExpr} = ${value}`,
+          arrContains(value)
+        ]));
       case "ne":
-        return q.whereNot(text, "=", value);
+        return q.where(sql`${textExpr} <> ${value}`);
       case "in": {
         const vals = this.toArray(value);
-        return q.where((builder) => {
-          vals.forEach((val) => {
-            builder.orWhere(text, "=", val);
-            builder.orWhere(arrContains(val));
-          });
-        });
+        return q.where((eb) => eb.or(
+          vals.flatMap((val) => [
+            sql`${textExpr} = ${val}`,
+            arrContains(val)
+          ])
+        ));
       }
       case "nin": {
         const vals = this.toArray(value);
-        return q.whereNotIn(text, vals);
+        return q.where(sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
       }
       case "like":
-        return q.where(text, "like", value);
+        return q.where(sql`${textExpr} like ${value}`);
       case "ilike":
-        return q.where(text, "ilike", value);
+        return q.where(sql`${textExpr} ilike ${value}`);
       case "exists":
-        return value ? q.whereRaw(`${text.toString()} is not null`) : q.whereRaw(`${text.toString()} is null`);
+        return value ? q.where(sql`${textExpr} is not null`) : q.where(sql`${textExpr} is null`);
       case "gt":
       case "gte":
       case "lt":
       case "lte": {
-        const operator = op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=";
-        return q.where(text, operator, value);
+        const operator = sql.raw(op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=");
+        return q.where(sql`${textExpr} ${operator} ${value}`);
       }
       default:
         return q;
     }
   }
-  applyIndexDocFilterFromAlias(knex, q, alias, entityType, key, op, value, recordIdColumn, search) {
-    const text = knex.raw(`(${alias}.doc ->> ?)`, [key]);
+  applyIndexDocFilterFromAlias(q, alias, entityType, key, op, value, recordIdColumn, search) {
+    const textExpr = sql`(${sql.ref(alias + ".doc")} ->> ${key})`;
     if ((op === "like" || op === "ilike") && search?.enabled && typeof value === "string") {
       const tokens = tokenizeText(String(value), search.config);
       const hashes = tokens.hashes;
       if (hashes.length) {
-        const applied = this.applySearchTokens(q, {
-          knex,
+        const applied = q.where((eb) => eb.exists(this.buildSearchTokensSub(eb, {
           entity: entityType,
           field: key,
           hashes,
           recordIdColumn,
           tenantId: search.tenantId ?? null,
           organizationScope: search.organizationScope ?? null
-        });
+        })));
         this.logSearchDebug("search:index-doc-filter", {
           entity: entityType,
           field: key,
           tokens: tokens.tokens,
           hashes,
-          applied,
+          applied: true,
           tenantId: search.tenantId ?? null,
           organizationScope: search.organizationScope
         });
-        if (applied) return q;
+        return applied;
       } else {
-        this.logSearchDebug("search:index-doc-skip-empty-hashes", {
-          entity: entityType,
-          field: key,
-          value
-        });
+        this.logSearchDebug("search:index-doc-skip-empty-hashes", { entity: entityType, field: key, value });
       }
       return q;
     }
     switch (op) {
       case "eq":
-        return q.where(text, "=", value);
+        return q.where(sql`${textExpr} = ${value}`);
       case "ne":
-        return q.where(text, "!=", value);
+        return q.where(sql`${textExpr} <> ${value}`);
+      case "in": {
+        const vals = this.toArray(value);
+        return q.where(sql`${textExpr} in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
+      }
+      case "nin": {
+        const vals = this.toArray(value);
+        return q.where(sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
+      }
+      case "like":
+        return q.where(sql`${textExpr} like ${value}`);
+      case "ilike":
+        return q.where(sql`${textExpr} ilike ${value}`);
+      case "exists":
+        return value ? q.where(sql`${textExpr} is not null`) : q.where(sql`${textExpr} is null`);
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte": {
+        const operator = sql.raw(op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=");
+        return q.where(sql`${textExpr} ${operator} ${value}`);
+      }
+      default:
+        return q;
+    }
+  }
+  /**
+   * Build a single OR-group base filter expression as a Kysely predicate
+   * (no side effects on the outer builder).
+   */
+  buildBaseFilterExpression(eb, filter, resolveBaseColumn, qualify, entity, searchRuntime) {
+    const fieldName = String(filter.field);
+    const baseField = resolveBaseColumn(fieldName);
+    if (!baseField) {
+      return this.buildIndexDocFilterExpression(eb, "ei", entity, fieldName, filter.op, filter.value, "b.id", searchRuntime);
+    }
+    return this.buildColumnFilterExpression(eb, qualify(baseField), filter.op, filter.value);
+  }
+  buildColumnFilterExpression(eb, column, op, value) {
+    switch (op) {
+      case "eq":
+        return eb(column, "=", value);
+      case "ne":
+        return eb(column, "!=", value);
+      case "gt":
+        return eb(column, ">", value);
+      case "gte":
+        return eb(column, ">=", value);
+      case "lt":
+        return eb(column, "<", value);
+      case "lte":
+        return eb(column, "<=", value);
       case "in":
-        return q.whereIn(text, this.toArray(value));
+        return eb(column, "in", this.toArray(value));
       case "nin":
-        return q.whereNotIn(text, this.toArray(value));
+        return eb(column, "not in", this.toArray(value));
       case "like":
-        return q.where(text, "like", value);
+        return eb(column, "like", value);
       case "ilike":
-        return q.where(text, "ilike", value);
+        return eb(column, "ilike", value);
       case "exists":
-        return value ? q.whereRaw(`${text.toString()} is not null`) : q.whereRaw(`${text.toString()} is null`);
+        return eb(column, value ? "is not" : "is", null);
+      default:
+        return sql`true`;
+    }
+  }
+  buildIndexDocFilterExpression(eb, alias, _entity, key, op, value, _recordIdColumn, _search) {
+    const textExpr = sql`(${sql.ref(alias + ".doc")} ->> ${key})`;
+    switch (op) {
+      case "eq":
+        return sql`${textExpr} = ${value}`;
+      case "ne":
+        return sql`${textExpr} <> ${value}`;
       case "gt":
       case "gte":
       case "lt":
       case "lte": {
-        const operator = op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=";
-        return q.where(text, operator, value);
+        const operator = sql.raw(op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=");
+        return sql`${textExpr} ${operator} ${value}`;
+      }
+      case "like":
+        return sql`${textExpr} like ${value}`;
+      case "ilike":
+        return sql`${textExpr} ilike ${value}`;
+      case "in": {
+        const vals = this.toArray(value);
+        return sql`${textExpr} in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`;
       }
+      case "nin": {
+        const vals = this.toArray(value);
+        return sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`;
+      }
+      case "exists":
+        return value ? sql`${textExpr} is not null` : sql`${textExpr} is null`;
       default:
-        return q;
+        return sql`true`;
     }
   }
   async queryCustomEntity(entity, opts = {}) {
-    const knex = this.getKnex();
+    const db = this.getDb();
     const alias = "ce";
-    let q = knex({ [alias]: "custom_entities_storage" }).where(`${alias}.entity_type`, entity);
     const orgScope = this.resolveOrganizationScope(opts);
     if (!opts.tenantId) throw new Error("QueryEngine: tenantId is required");
-    q = q.andWhere(`${alias}.tenant_id`, opts.tenantId);
-    if (orgScope) {
-      q = this.applyOrganizationScope(q, `${alias}.organization_id`, orgScope);
-    }
-    if (!opts.withDeleted) q = q.whereNull(`${alias}.deleted_at`);
     const searchConfig = resolveSearchConfig();
     const searchEnabled = searchConfig.enabled && await this.tableExists("search_tokens");
     const hasSearchTokens = searchEnabled ? await this.hasSearchTokens(entity, opts.tenantId ?? null, orgScope) : false;
@@ -1174,31 +1217,37 @@ class HybridQueryEngine {
       tenantId: opts.tenantId ?? null
     };
     const normalizedFilters = normalizeFilters(opts.filters);
-    for (const filter of normalizedFilters) {
-      if (filter.field.startsWith("cf:")) {
-        q = this.applyCfFilterFromAlias(knex, q, alias, entity, filter.field, filter.op, filter.value, searchRuntime);
-        continue;
+    const applyScope = (q) => {
+      let next = q.where(`${alias}.entity_type`, "=", entity).where(`${alias}.tenant_id`, "=", opts.tenantId);
+      if (orgScope) {
+        next = this.applyOrganizationScope(next, `${alias}.organization_id`, orgScope);
       }
-      const column = this.resolveCustomEntityColumn(alias, String(filter.field));
-      if (column) {
-        q = this.applyColumnFilter(q, column, filter, {
+      if (!opts.withDeleted) next = next.where(`${alias}.deleted_at`, "is", null);
+      for (const filter of normalizedFilters) {
+        if (filter.field.startsWith("cf:")) {
+          next = this.applyCfFilterFromAlias(next, alias, entity, filter.field, filter.op, filter.value, searchRuntime);
+          continue;
+        }
+        const column = this.resolveCustomEntityColumn(alias, String(filter.field));
+        if (column) {
+          next = this.applyColumnFilter(next, column, filter, {
+            ...searchRuntime,
+            entity,
+            field: String(filter.field),
+            recordIdColumn: `${alias}.entity_id`
+          });
+          continue;
+        }
+        const docExpr = sql`(${sql.ref(alias + ".doc")} ->> ${String(filter.field)})`;
+        next = this.applyColumnFilter(next, docExpr, filter, {
           ...searchRuntime,
-          knex,
           entity,
           field: String(filter.field),
           recordIdColumn: `${alias}.entity_id`
         });
-        continue;
       }
-      const docExpr = knex.raw(`(${alias}.doc ->> ?)`, [String(filter.field)]);
-      q = this.applyColumnFilter(q, docExpr, filter, {
-        ...searchRuntime,
-        knex,
-        entity,
-        field: String(filter.field),
-        recordIdColumn: `${alias}.entity_id`
-      });
-    }
+      return next;
+    };
     const cfKeys = /* @__PURE__ */ new Set();
     for (const f of opts.fields || []) {
       if (typeof f === "string" && f.startsWith("cf:")) cfKeys.add(f.slice(3));
@@ -1210,90 +1259,87 @@ class HybridQueryEngine {
     }
     if (opts.includeCustomFields === true) {
       try {
-        const rows = await knex("custom_field_defs").select("key").where({ entity_id: entity, is_active: true }).modify((qb) => {
-          qb.andWhere({ tenant_id: opts.tenantId });
-        });
+        const rows = await db.selectFrom("custom_field_defs").select("key").where("entity_id", "=", entity).where("is_active", "=", true).where("tenant_id", "=", opts.tenantId).execute();
         for (const row of rows) {
           const key = row.key;
-          if (typeof key === "string") {
-            cfKeys.add(key);
-          } else if (key != null) {
-            cfKeys.add(String(key));
-          }
+          if (typeof key === "string") cfKeys.add(key);
+          else if (key != null) cfKeys.add(String(key));
         }
       } catch {
       }
     } else if (Array.isArray(opts.includeCustomFields)) {
       for (const k of opts.includeCustomFields) cfKeys.add(k);
     }
-    const requested = opts.fields && opts.fields.length ? opts.fields : ["id"];
-    for (const field of requested) {
-      const f = String(field);
-      if (f.startsWith("cf:")) {
-        const aliasName = this.sanitize(f);
-        const expr = this.jsonbRawAlias(knex, alias, f);
-        q = q.select({ [aliasName]: expr });
-      } else if (f === "id") {
-        q = q.select(knex.raw(`${alias}.entity_id as ??`, ["id"]));
-      } else if (f === "created_at" || f === "updated_at" || f === "deleted_at") {
-        q = q.select(knex.raw(`${alias}.?? as ??`, [f, f]));
-      } else {
-        const expr = knex.raw(`(${alias}.doc ->> ?)`, [f]);
-        q = q.select({ [f]: expr });
+    const applySelection = (q) => {
+      let next = q;
+      const requested = opts.fields && opts.fields.length ? opts.fields : ["id"];
+      for (const field of requested) {
+        const f = String(field);
+        if (f.startsWith("cf:")) {
+          const aliasName = this.sanitize(f);
+          next = next.select(this.jsonbSqlAlias(alias, f).as(aliasName));
+        } else if (f === "id") {
+          next = next.select(`${alias}.entity_id as id`);
+        } else if (f === "created_at" || f === "updated_at" || f === "deleted_at") {
+          next = next.select(`${alias}.${f} as ${f}`);
+        } else {
+          const expr = sql`(${sql.ref(alias + ".doc")} ->> ${f})`;
+          next = next.select(expr.as(f));
+        }
       }
-    }
-    const cfSelectedAliases = [];
-    for (const key of cfKeys) {
-      const aliasName = this.sanitize(`cf:${key}`);
-      const expr = this.jsonbRawAlias(knex, alias, `cf:${key}`);
-      q = q.select({ [aliasName]: expr });
-      cfSelectedAliases.push(aliasName);
-    }
-    for (const s of opts.sort || []) {
-      if (s.field.startsWith("cf:")) {
-        const key = s.field.slice(3);
+      for (const key of cfKeys) {
         const aliasName = this.sanitize(`cf:${key}`);
-        if (!cfSelectedAliases.includes(aliasName)) {
-          const expr = this.jsonbRawAlias(knex, alias, `cf:${key}`);
-          q = q.select({ [aliasName]: expr });
-          cfSelectedAliases.push(aliasName);
+        next = next.select(this.jsonbSqlAlias(alias, `cf:${key}`).as(aliasName));
+      }
+      return next;
+    };
+    const applySort = (q) => {
+      let next = q;
+      for (const s of opts.sort || []) {
+        if (s.field.startsWith("cf:")) {
+          const key = s.field.slice(3);
+          const aliasName = this.sanitize(`cf:${key}`);
+          next = next.orderBy(aliasName, s.dir ?? SortDir.Asc);
+        } else if (s.field === "id") {
+          next = next.orderBy(`${alias}.entity_id`, s.dir ?? SortDir.Asc);
+        } else if (s.field === "created_at" || s.field === "updated_at" || s.field === "deleted_at") {
+          next = next.orderBy(`${alias}.${s.field}`, s.dir ?? SortDir.Asc);
+        } else {
+          const direction = sql.raw(String(s.dir ?? SortDir.Asc));
+          next = next.orderBy(sql`(${sql.ref(alias + ".doc")} ->> ${s.field}) ${direction}`);
         }
-        q = q.orderBy(aliasName, s.dir ?? SortDir.Asc);
-      } else if (s.field === "id") {
-        q = q.orderBy(`${alias}.entity_id`, s.dir ?? SortDir.Asc);
-      } else if (s.field === "created_at" || s.field === "updated_at" || s.field === "deleted_at") {
-        q = q.orderBy(`${alias}.${s.field}`, s.dir ?? SortDir.Asc);
-      } else {
-        const direction = s.dir ?? SortDir.Asc;
-        q = q.orderByRaw(`(${alias}.doc ->> ?) ${direction}`, [s.field]);
       }
-    }
+      return next;
+    };
     const page = opts.page?.page ?? 1;
     const pageSize = opts.page?.pageSize ?? 20;
-    const countClone = q.clone();
-    if (typeof countClone.clearSelect === "function") countClone.clearSelect();
-    if (typeof countClone.clearOrder === "function") countClone.clearOrder();
-    const countRow = await countClone.countDistinct(`${alias}.entity_id as count`).first();
+    const root = db.selectFrom(`custom_entities_storage as ${alias}`);
+    const countQuery = applyScope(root).select(sql`count(distinct ${sql.ref(`${alias}.entity_id`)})`.as("count"));
+    const countRow = await countQuery.executeTakeFirst();
     const total = this.parseCount(countRow);
-    const items = await q.limit(pageSize).offset((page - 1) * pageSize);
+    let dataQuery = applyScope(db.selectFrom(`custom_entities_storage as ${alias}`));
+    dataQuery = applySelection(dataQuery);
+    dataQuery = applySort(dataQuery);
+    dataQuery = dataQuery.limit(pageSize).offset((page - 1) * pageSize);
+    const items = await dataQuery.execute();
     return { items, page, pageSize, total };
   }
   async tableExists(table) {
-    const knex = this.getKnex();
-    const exists = await knex("information_schema.tables").where({ table_name: table }).first();
+    const db = this.getDb();
+    const exists = await db.selectFrom("information_schema.tables").select(sql`1`.as("one")).where("table_name", "=", table).executeTakeFirst();
     return !!exists;
   }
   async hasSearchTokens(entity, tenantId, orgScope) {
     try {
-      const knex = this.getKnex();
-      const query = knex("search_tokens").select(1).where("entity_type", entity).limit(1);
+      const db = this.getDb();
+      let query = db.selectFrom("search_tokens").select(sql`1`.as("one")).where("entity_type", "=", entity);
       if (tenantId !== void 0) {
-        query.andWhereRaw("tenant_id is not distinct from ?", [tenantId]);
+        query = query.where(sql`tenant_id is not distinct from ${tenantId}`);
       }
       if (orgScope) {
-        this.applyOrganizationScope(query, "search_tokens.organization_id", orgScope);
+        query = this.applyOrganizationScope(query, "search_tokens.organization_id", orgScope);
       }
-      const row = await query.first();
+      const row = await query.limit(1).executeTakeFirst();
       return !!row;
     } catch (err) {
       this.logSearchDebug("search:has-tokens-error", {
@@ -1324,17 +1370,14 @@ class HybridQueryEngine {
     const cacheKey = this.customFieldKeysCacheKey(entityIds, tenantId);
     const now = Date.now();
     const cached = this.customFieldKeysCache.get(cacheKey);
-    if (cached && cached.expiresAt > now) {
-      return cached.value.slice();
-    }
-    const knex = this.getKnex();
-    const rows = await knex("custom_field_defs").select("key").whereIn("entity_id", entityIds).andWhere("is_active", true).modify((qb) => {
-      qb.andWhere((inner) => {
-        inner.where({ tenant_id: tenantId }).orWhereNull("tenant_id");
-      });
-    });
+    if (cached && cached.expiresAt > now) return cached.value.slice();
+    const db = this.getDb();
+    const rows = await db.selectFrom("custom_field_defs").select("key").where("entity_id", "in", entityIds).where("is_active", "=", true).where((eb) => eb.or([
+      eb("tenant_id", "=", tenantId),
+      eb("tenant_id", "is", null)
+    ])).execute();
     const keys = /* @__PURE__ */ new Set();
-    for (const row of rows || []) {
+    for (const row of rows) {
       const key = row.key;
       if (typeof key === "string" && key.trim().length) keys.add(key.trim());
       else if (key != null) keys.add(String(key));
@@ -1376,27 +1419,24 @@ class HybridQueryEngine {
     return entity;
   }
   async indexAnyRows(entity) {
-    const knex = this.getKnex();
-    const coverage = await knex("entity_index_coverage").select(1).where("entity_type", entity).where("indexed_count", ">", 0).first();
+    const db = this.getDb();
+    const coverage = await db.selectFrom("entity_index_coverage").select(sql`1`.as("one")).where("entity_type", "=", entity).where("indexed_count", ">", 0).executeTakeFirst();
     if (coverage) return true;
-    const exists = await knex("entity_indexes").select("entity_id").where({ entity_type: entity }).first();
+    const exists = await db.selectFrom("entity_indexes").select("entity_id").where("entity_type", "=", entity).executeTakeFirst();
     return !!exists;
   }
   async getStoredCoverageSnapshot(entity, tenantId, organizationId, withDeleted) {
     try {
       if (!this.isCoverageOptimizationEnabled()) {
-        await refreshCoverageSnapshot(
-          this.em,
-          {
-            entityType: entity,
-            tenantId,
-            organizationId,
-            withDeleted
-          }
-        );
+        await refreshCoverageSnapshot(this.em, {
+          entityType: entity,
+          tenantId,
+          organizationId,
+          withDeleted
+        });
       }
-      const knex = this.getKnex();
-      const row = await readCoverageSnapshot(knex, {
+      const db = this.getDb();
+      const row = await readCoverageSnapshot(db, {
         entityType: entity,
         tenantId,
         organizationId,
@@ -1427,13 +1467,7 @@ class HybridQueryEngine {
       organizationId: organizationIdOverride ?? opts.organizationId ?? null,
       force: false
     };
-    const context = stats ? {
-      entity,
-      tenantId: payload.tenantId,
-      organizationId: payload.organizationId,
-      baseCount: stats.baseCount,
-      indexedCount: stats.indexedCount
-    } : { entity, tenantId: payload.tenantId, organizationId: payload.organizationId };
+    const context = stats ? { entity, tenantId: payload.tenantId, organizationId: payload.organizationId, baseCount: stats.baseCount, indexedCount: stats.indexedCount } : { entity, tenantId: payload.tenantId, organizationId: payload.organizationId };
     void Promise.resolve().then(async () => {
       try {
         await bus.emitEvent("query_index.reindex", payload, { persistent: true });
@@ -1449,12 +1483,7 @@ class HybridQueryEngine {
   scheduleCoverageRefresh(entity, tenantId, organizationId, withDeleted) {
     const bus = this.resolveEventBus();
     if (!bus) return;
-    const key = [
-      entity,
-      tenantId ?? "__tenant__",
-      organizationId ?? "__org__",
-      withDeleted ? "1" : "0"
-    ].join("|");
+    const key = [entity, tenantId ?? "__tenant__", organizationId ?? "__org__", withDeleted ? "1" : "0"].join("|");
     if (this.pendingCoverageRefreshKeys.has(key)) return;
     this.pendingCoverageRefreshKeys.add(key);
     void Promise.resolve().then(async () => {
@@ -1526,17 +1555,17 @@ class HybridQueryEngine {
       if (cached === true) return true;
       this.columnCache.delete(key);
     }
-    const knex = this.getKnex();
-    const exists = await knex("information_schema.columns").where({ table_name: table, column_name: column }).first();
+    const db = this.getDb();
+    const exists = await db.selectFrom("information_schema.columns").select(sql`1`.as("one")).where("table_name", "=", table).where("column_name", "=", column).executeTakeFirst();
     const present = !!exists;
     if (present) this.columnCache.set(key, true);
     else this.columnCache.delete(key);
     return present;
   }
   async getBaseColumnsForEntity(entity) {
-    const knex = this.getKnex();
+    const db = this.getDb();
     const table = resolveEntityTableName(this.em, entity);
-    const rows = await knex("information_schema.columns").select("column_name", "data_type").where({ table_name: table });
+    const rows = await db.selectFrom("information_schema.columns").select(["column_name", "data_type"]).where("table_name", "=", table).execute();
     const map = /* @__PURE__ */ new Map();
     for (const r of rows) map.set(r.column_name, r.data_type);
     return map;
@@ -1568,20 +1597,14 @@ class HybridQueryEngine {
   }
   applyOrganizationScope(q, column, scope) {
     if (scope.ids.length === 0 && !scope.includeNull) {
-      return q.whereRaw("1 = 0");
+      return q.where(sql`1 = 0`);
     }
-    return q.where((builder) => {
-      let applied = false;
-      if (scope.ids.length > 0) {
-        builder.whereIn(column, scope.ids);
-        applied = true;
-      }
-      if (scope.includeNull) {
-        if (applied) builder.orWhereNull(column);
-        else builder.whereNull(column);
-      } else if (!applied) {
-        builder.whereRaw("1 = 0");
-      }
+    return q.where((eb) => {
+      const parts = [];
+      if (scope.ids.length > 0) parts.push(eb(column, "in", scope.ids));
+      if (scope.includeNull) parts.push(eb(column, "is", null));
+      if (parts.length === 1) return parts[0];
+      return eb.or(parts);
     });
   }
   normalizeFilters(filters) {
@@ -1647,12 +1670,8 @@ class HybridQueryEngine {
     return s.replace(/[^a-zA-Z0-9_]/g, "_");
   }
   toArray(value) {
-    if (Array.isArray(value)) {
-      return value;
-    }
-    if (value === void 0) {
-      return [];
-    }
+    if (Array.isArray(value)) return value;
+    if (value === void 0) return [];
     return [value];
   }
   parseCount(row) {
@@ -1663,6 +1682,7 @@ class HybridQueryEngine {
         const parsed = Number(value);
         return Number.isNaN(parsed) ? 0 : parsed;
       }
+      if (typeof value === "bigint") return Number(value);
     }
     return 0;
   }
@@ -1680,35 +1700,30 @@ class HybridQueryEngine {
       const hashes = tokens.hashes;
       if (hashes.length) {
         const sources = (search.searchSources && search.searchSources.length ? search.searchSources : [{ entity: search.entity, recordIdColumn: search.recordIdColumn ?? "" }]).filter((src) => src.recordIdColumn && src.entity);
-        let applied = false;
         if (sources.length) {
-          q = q.where((qb) => {
-            sources.forEach((src, idx) => {
-              const ok = this.applySearchTokens(qb, {
-                knex: search.knex,
-                entity: src.entity,
-                field: search.field,
-                hashes,
-                recordIdColumn: src.recordIdColumn,
-                tenantId: search.tenantId ?? null,
-                organizationScope: search.organizationScope ?? null,
-                combineWith: idx === 0 ? "and" : "or"
-              });
-              if (ok) applied = true;
-            });
+          const engine = this;
+          q = q.where((eb) => eb.or(
+            sources.map((src) => eb.exists(engine.buildSearchTokensSub(eb, {
+              entity: src.entity,
+              field: search.field,
+              hashes,
+              recordIdColumn: src.recordIdColumn,
+              tenantId: search.tenantId ?? null,
+              organizationScope: search.organizationScope ?? null
+            })))
+          ));
+          this.logSearchDebug("search:filter", {
+            entity: search.entity,
+            field: search.field,
+            tokens: tokens.tokens,
+            hashes,
+            applied: true,
+            tenantId: search.tenantId ?? null,
+            organizationScope: search.organizationScope,
+            sources: sources.map((src) => ({ entity: src.entity, recordIdColumn: src.recordIdColumn }))
           });
+          return q;
         }
-        this.logSearchDebug("search:filter", {
-          entity: search.entity,
-          field: search.field,
-          tokens: tokens.tokens,
-          hashes,
-          applied,
-          tenantId: search.tenantId ?? null,
-          organizationScope: search.organizationScope,
-          sources: sources.map((src) => ({ entity: src.entity, recordIdColumn: src.recordIdColumn }))
-        });
-        if (applied) return q;
       } else {
         this.logSearchDebug("search:skip-empty-hashes", {
           entity: search.entity,
@@ -1721,9 +1736,9 @@ class HybridQueryEngine {
     const col = column;
     switch (filter.op) {
       case "eq":
-        return q.where(col, filter.value);
+        return q.where(col, "=", filter.value);
       case "ne":
-        return q.whereNot(col, filter.value);
+        return q.where(col, "!=", filter.value);
       case "gt":
       case "gte":
       case "lt":
@@ -1731,20 +1746,16 @@ class HybridQueryEngine {
         const operator = filter.op === "gt" ? ">" : filter.op === "gte" ? ">=" : filter.op === "lt" ? "<" : "<=";
         return q.where(col, operator, filter.value);
       }
-      case "in": {
-        const values = this.toArray(filter.value);
-        return q.whereIn(col, values);
-      }
-      case "nin": {
-        const values = this.toArray(filter.value);
-        return q.whereNotIn(col, values);
-      }
+      case "in":
+        return q.where(col, "in", this.toArray(filter.value));
+      case "nin":
+        return q.where(col, "not in", this.toArray(filter.value));
       case "like":
         return q.where(col, "like", filter.value);
       case "ilike":
         return q.where(col, "ilike", filter.value);
       case "exists":
-        return filter.value ? q.whereNotNull(col) : q.whereNull(col);
+        return filter.value ? q.where(col, "is not", null) : q.where(col, "is", null);
       default:
         return q;
     }
@@ -1785,9 +1796,7 @@ class HybridQueryEngine {
     const baseCount = snapshot.baseCount;
     const indexCount = snapshot.indexedCount;
     const hasGap = baseCount > 0 && indexCount < baseCount;
-    if (hasGap || indexCount > baseCount) {
-      return { stats: snapshot, scope: "scoped" };
-    }
+    if (hasGap || indexCount > baseCount) return { stats: snapshot, scope: "scoped" };
     return null;
   }
   // Backward-compatible hook for tests that mock coverage stats
@@ -1798,18 +1807,13 @@ class HybridQueryEngine {
   async captureSqlTiming(label, entity, execute, extra, profiler) {
     const shouldDebug = this.isSqlDebugEnabled() && this.isDebugVerbosity();
     const shouldProfile = profiler?.enabled === true;
-    if (!shouldDebug && !shouldProfile) {
-      return Promise.resolve(execute());
-    }
+    if (!shouldDebug && !shouldProfile) return Promise.resolve(execute());
     const startedAt = process.hrtime.bigint();
     try {
       return await Promise.resolve(execute());
     } finally {
       const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1e6;
-      const context = {
-        entity,
-        durationMs: Math.round(elapsedMs * 1e3) / 1e3
-      };
+      const context = { entity, durationMs: Math.round(elapsedMs * 1e3) / 1e3 };
       if (extra) Object.assign(context, extra);
       if (shouldProfile) profiler.record(label, context.durationMs, extra);
       if (shouldDebug) this.debug(`${label}:timing`, context);