document-dataply 0.0.10-alpha.3 → 0.0.10-alpha.5

package/dist/cjs/index.js

@@ -95,7 +95,7 @@ var require_cjs = __commonJS({
       StringComparator: () => StringComparator,
       SyncMVCCStrategy: () => SyncMVCCStrategy2,
       SyncMVCCTransaction: () => SyncMVCCTransaction2,
-      Transaction: () => Transaction3,
+      Transaction: () => Transaction4,
       UnknownPageManager: () => UnknownPageManager,
       ValueComparator: () => ValueComparator2
     });
@@ -9598,7 +9598,7 @@ var require_cjs = __commonJS({
         }
       }
     };
-    var Transaction3 = class {
+    var Transaction4 = class {
       /**
        * @param id Transaction ID
        * @param context Transaction context
@@ -9997,7 +9997,7 @@ var require_cjs = __commonJS({
        * @returns Transaction object
        */
       createTransaction() {
-        return new Transaction3(
+        return new Transaction4(
           ++this.txIdCounter,
           this.txContext,
           this.pfs.getPageStrategy(),
@@ -10383,88 +10383,17 @@ var require_cjs = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   DocumentDataply: () => DocumentDataply,
-  GlobalTransaction: () => import_dataply4.GlobalTransaction,
-  Transaction: () => import_dataply4.Transaction
+  GlobalTransaction: () => import_dataply5.GlobalTransaction,
+  Transaction: () => import_dataply5.Transaction
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/core/documentAPI.ts
-var os = __toESM(require("node:os"));
-var import_dataply3 = __toESM(require_cjs());
-
-// src/core/bptree/documentStrategy.ts
-var import_dataply = __toESM(require_cjs());
-var DocumentSerializeStrategyAsync = class extends import_dataply.SerializeStrategyAsync {
-  constructor(order, api, txContext, treeKey) {
-    super(order);
-    this.api = api;
-    this.txContext = txContext;
-    this.treeKey = treeKey;
-  }
-  /**
-   * readHead에서 할당된 headPk를 캐싱하여
-   * writeHead에서 AsyncLocalStorage 컨텍스트 유실 시에도 사용할 수 있도록 함
-   */
-  cachedHeadPk = null;
-  async id(isLeaf) {
-    const tx = this.txContext.get();
-    const pk = await this.api.insertAsOverflow("__BPTREE_NODE_PLACEHOLDER__", false, tx);
-    return pk + "";
-  }
-  async read(id) {
-    const tx = this.txContext.get();
-    const row = await this.api.select(Number(id), false, tx);
-    if (row === null || row === "" || row.startsWith("__BPTREE_")) {
-      throw new Error(`Node not found or empty with ID: ${id}`);
-    }
-    return JSON.parse(row);
-  }
-  async write(id, node) {
-    const tx = this.txContext.get();
-    const json = JSON.stringify(node);
-    await this.api.update(+id, json, tx);
-  }
-  async delete(id) {
-    const tx = this.txContext.get();
-    await this.api.delete(+id, false, tx);
-  }
-  async readHead() {
-    const tx = this.txContext.get();
-    const metadata = await this.api.getDocumentInnerMetadata(tx);
-    const indexInfo = metadata.indices[this.treeKey];
-    if (!indexInfo) return null;
-    const headPk = indexInfo[0];
-    if (headPk === -1) {
-      const pk = await this.api.insertAsOverflow("__BPTREE_HEAD_PLACEHOLDER__", false, tx);
-      metadata.indices[this.treeKey][0] = pk;
-      await this.api.updateDocumentInnerMetadata(metadata, tx);
-      this.cachedHeadPk = pk;
-      return null;
-    }
-    this.cachedHeadPk = headPk;
-    const row = await this.api.select(headPk, false, tx);
-    if (row === null || row === "" || row.startsWith("__BPTREE_")) return null;
-    return JSON.parse(row);
-  }
-  async writeHead(head) {
-    const tx = this.txContext.get();
-    let headPk = this.cachedHeadPk;
-    if (headPk === null) {
-      const metadata = await this.api.getDocumentInnerMetadata(tx);
-      const indexInfo = metadata.indices[this.treeKey];
-      if (!indexInfo) {
-        throw new Error(`Index info not found for tree: ${this.treeKey}. Initialization should be handled outside.`);
-      }
-      headPk = indexInfo[0];
-    }
-    const json = JSON.stringify(head);
-    await this.api.update(headPk, json, tx);
-  }
-};
+var import_dataply4 = __toESM(require_cjs());
 
 // src/core/bptree/documentComparator.ts
-var import_dataply2 = __toESM(require_cjs());
-var DocumentValueComparator = class extends import_dataply2.ValueComparator {
+var import_dataply = __toESM(require_cjs());
+var DocumentValueComparator = class extends import_dataply.ValueComparator {
   primaryAsc(a, b) {
     return this._compareValue(a.v, b.v);
   }
@@ -10505,76 +10434,6 @@ var DocumentValueComparator = class extends import_dataply2.ValueComparator {
   }
 };
 
-// src/utils/catchPromise.ts
-async function catchPromise(promise) {
-  return promise.then((res) => [void 0, res]).catch((reason) => [reason]);
-}
-
-// src/utils/heap.ts
-var BinaryHeap = class {
-  constructor(comparator) {
-    this.comparator = comparator;
-  }
-  heap = [];
-  get size() {
-    return this.heap.length;
-  }
-  peek() {
-    return this.heap[0];
-  }
-  push(value) {
-    this.heap.push(value);
-    this.bubbleUp(this.heap.length - 1);
-  }
-  pop() {
-    if (this.size === 0) return void 0;
-    const top = this.heap[0];
-    const bottom = this.heap.pop();
-    if (this.size > 0) {
-      this.heap[0] = bottom;
-      this.sinkDown(0);
-    }
-    return top;
-  }
-  /**
-   * Replace the root element with a new value and re-heapify.
-   * Faster than pop() followed by push().
-   */
-  replace(value) {
-    const top = this.heap[0];
-    this.heap[0] = value;
-    this.sinkDown(0);
-    return top;
-  }
-  toArray() {
-    return [...this.heap];
-  }
-  bubbleUp(index) {
-    while (index > 0) {
-      const parentIndex = Math.floor((index - 1) / 2);
-      if (this.comparator(this.heap[index], this.heap[parentIndex]) >= 0) break;
-      [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
-      index = parentIndex;
-    }
-  }
-  sinkDown(index) {
-    while (true) {
-      let smallest = index;
-      const left = 2 * index + 1;
-      const right = 2 * index + 2;
-      if (left < this.size && this.comparator(this.heap[left], this.heap[smallest]) < 0) {
-        smallest = left;
-      }
-      if (right < this.size && this.comparator(this.heap[right], this.heap[smallest]) < 0) {
-        smallest = right;
-      }
-      if (smallest === index) break;
-      [this.heap[index], this.heap[smallest]] = [this.heap[smallest], this.heap[index]];
-      index = smallest;
-    }
-  }
-};
-
 // src/utils/tokenizer.ts
 function whitespaceTokenize(text) {
   if (typeof text !== "string") return [];
@@ -10606,168 +10465,984 @@ function tokenize(text, options) {
   return [];
 }
 
-// src/core/documentAPI.ts
-var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
-  indices = {};
-  trees = /* @__PURE__ */ new Map();
-  comparator = new DocumentValueComparator();
-  pendingBackfillFields = [];
-  _initialized = false;
-  indexedFields;
-  /**
-   * Registered indices via createIndex() (before init)
-   * Key: index name, Value: index configuration
-   */
-  pendingCreateIndices = /* @__PURE__ */ new Map();
-  /**
-   * Resolved index configurations after init.
-   * Key: index name, Value: index config (from metadata)
-   */
-  registeredIndices = /* @__PURE__ */ new Map();
-  /**
-   * Maps field name → index names that cover this field.
-   * Used for query resolution.
-   */
-  fieldToIndices = /* @__PURE__ */ new Map();
-  operatorConverters = {
-    equal: "primaryEqual",
-    notEqual: "primaryNotEqual",
-    lt: "primaryLt",
-    lte: "primaryLte",
-    gt: "primaryGt",
-    gte: "primaryGte",
-    or: "primaryOr",
-    like: "like"
-  };
-  constructor(file, options) {
-    super(file, options);
-    this.trees = /* @__PURE__ */ new Map();
-    this.indexedFields = /* @__PURE__ */ new Set(["_id"]);
-    this.hook.onceAfter("init", async (tx, isNewlyCreated) => {
-      if (isNewlyCreated) {
-        await this.initializeDocumentFile(tx);
-      }
-      if (!await this.verifyDocumentFile(tx)) {
-        throw new Error("Document metadata verification failed");
-      }
-      const metadata = await this.getDocumentInnerMetadata(tx);
-      const targetIndices = /* @__PURE__ */ new Map([
-        ["_id", { type: "btree", fields: ["_id"] }]
-      ]);
-      for (const [name, info] of Object.entries(metadata.indices)) {
-        targetIndices.set(name, info[1]);
-      }
-      for (const [name, option] of this.pendingCreateIndices) {
-        const config = this.toIndexMetaConfig(option);
-        targetIndices.set(name, config);
-      }
-      const backfillTargets = [];
-      let isMetadataChanged = false;
-      for (const [indexName, config] of targetIndices) {
-        const existingIndex = metadata.indices[indexName];
-        if (!existingIndex) {
-          metadata.indices[indexName] = [-1, config];
-          isMetadataChanged = true;
-          if (!isNewlyCreated) {
-            backfillTargets.push(indexName);
-          }
-        } else {
-          const [_pk, existingConfig] = existingIndex;
-          if (JSON.stringify(existingConfig) !== JSON.stringify(config)) {
-            metadata.indices[indexName] = [_pk, config];
-            isMetadataChanged = true;
-            if (!isNewlyCreated) {
-              backfillTargets.push(indexName);
-            }
-          }
-        }
-      }
-      if (isMetadataChanged) {
-        await this.updateDocumentInnerMetadata(metadata, tx);
-      }
-      this.indices = metadata.indices;
-      this.registeredIndices = /* @__PURE__ */ new Map();
-      this.fieldToIndices = /* @__PURE__ */ new Map();
-      for (const [indexName, config] of targetIndices) {
-        this.registeredIndices.set(indexName, config);
-        const fields = this.getFieldsFromConfig(config);
-        for (const field of fields) {
-          this.indexedFields.add(field);
-          if (!this.fieldToIndices.has(field)) {
-            this.fieldToIndices.set(field, []);
-          }
-          this.fieldToIndices.get(field).push(indexName);
-        }
-      }
-      for (const indexName of targetIndices.keys()) {
-        if (metadata.indices[indexName]) {
-          const tree = new import_dataply3.BPTreeAsync(
-            new DocumentSerializeStrategyAsync(
-              this.rowTableEngine.order,
-              this,
-              this.txContext,
-              indexName
-            ),
-            this.comparator
-          );
-          await tree.init();
-          this.trees.set(indexName, tree);
-        }
-      }
-      this.pendingBackfillFields = backfillTargets;
-      this._initialized = true;
-      return tx;
-    });
-  }
-  /**
-   * Whether the document database has been initialized.
-   */
-  get isDocInitialized() {
-    return this._initialized;
-  }
-  /**
-   * Register an index. If called before init(), queues it for processing during init.
-   * If called after init(), immediately creates the tree, updates metadata, and backfills.
-   */
-  async registerIndex(name, option, tx) {
-    if (!this._initialized) {
-      this.pendingCreateIndices.set(name, option);
-      return;
-    }
-    await this.registerIndexRuntime(name, option, tx);
+// src/core/Optimizer.ts
+var Optimizer = class {
+  constructor(api) {
+    this.api = api;
   }
   /**
-   * Register an index at runtime (after init).
-   * Creates the tree, updates metadata, and backfills existing data.
+   * B-Tree 타입 인덱스의 선택도를 평가하고 트리에 부여할 조건을 산출합니다.
    */
-  async registerIndexRuntime(name, option, tx) {
-    const config = this.toIndexMetaConfig(option);
-    if (this.registeredIndices.has(name)) {
-      throw new Error(`Index "${name}" already exists.`);
-    }
-    await this.runWithDefaultWrite(async (tx2) => {
-      const metadata = await this.getDocumentInnerMetadata(tx2);
-      metadata.indices[name] = [-1, config];
-      await this.updateDocumentInnerMetadata(metadata, tx2);
-      this.indices = metadata.indices;
-      this.registeredIndices.set(name, config);
-      const fields = this.getFieldsFromConfig(config);
-      for (let i = 0; i < fields.length; i++) {
-        const field = fields[i];
-        this.indexedFields.add(field);
-        if (!this.fieldToIndices.has(field)) {
-          this.fieldToIndices.set(field, []);
-        }
-        this.fieldToIndices.get(field).push(name);
+  evaluateBTreeCandidate(indexName, config, query, queryFields, treeTx, orderByField) {
+    const primaryField = config.fields[0];
+    if (!queryFields.has(primaryField)) return null;
+    const builtCondition = {};
+    let score = 0;
+    let isConsecutive = true;
+    const coveredFields = [];
+    const compositeVerifyFields = [];
+    const startValues = [];
+    const endValues = [];
+    let startOperator = null;
+    let endOperator = null;
+    for (let i = 0, len = config.fields.length; i < len; i++) {
+      const field = config.fields[i];
+      if (!queryFields.has(field)) {
+        isConsecutive = false;
+        continue;
       }
-      const tree = new import_dataply3.BPTreeAsync(
+      coveredFields.push(field);
+      score += 1;
+      if (isConsecutive) {
+        const cond = query[field];
+        if (cond !== void 0) {
+          let isBounded = false;
+          if (typeof cond !== "object" || cond === null) {
+            score += 100;
+            startValues.push(cond);
+            endValues.push(cond);
+            startOperator = "primaryGte";
+            endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryEqual" in cond || "equal" in cond) {
+            const val = cond.primaryEqual?.v ?? cond.equal?.v ?? cond.primaryEqual ?? cond.equal;
+            score += 100;
+            startValues.push(val);
+            endValues.push(val);
+            startOperator = "primaryGte";
+            endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryGte" in cond || "gte" in cond) {
+            const val = cond.primaryGte?.v ?? cond.gte?.v ?? cond.primaryGte ?? cond.gte;
+            score += 50;
+            isConsecutive = false;
+            startValues.push(val);
+            startOperator = "primaryGte";
+            if (endValues.length > 0) endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryGt" in cond || "gt" in cond) {
+            const val = cond.primaryGt?.v ?? cond.gt?.v ?? cond.primaryGt ?? cond.gt;
+            score += 50;
+            isConsecutive = false;
+            startValues.push(val);
+            startOperator = "primaryGt";
+            if (endValues.length > 0) endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryLte" in cond || "lte" in cond) {
+            const val = cond.primaryLte?.v ?? cond.lte?.v ?? cond.primaryLte ?? cond.lte;
+            score += 50;
+            isConsecutive = false;
+            endValues.push(val);
+            endOperator = "primaryLte";
+            if (startValues.length > 0) startOperator = "primaryGte";
+            isBounded = true;
+          } else if ("primaryLt" in cond || "lt" in cond) {
+            const val = cond.primaryLt?.v ?? cond.lt?.v ?? cond.primaryLt ?? cond.lt;
+            score += 50;
+            isConsecutive = false;
+            endValues.push(val);
+            endOperator = "primaryLt";
+            if (startValues.length > 0) startOperator = "primaryGte";
+            isBounded = true;
+          } else if ("primaryOr" in cond || "or" in cond) {
+            score += 20;
+            isConsecutive = false;
+          } else if ("like" in cond) {
+            score += 15;
+            isConsecutive = false;
+          } else {
+            score += 10;
+            isConsecutive = false;
+          }
+          if (!isBounded && field !== primaryField) {
+            compositeVerifyFields.push(field);
+          }
+        }
+      } else {
+        if (field !== primaryField) {
+          compositeVerifyFields.push(field);
+        }
+      }
+    }
+    if (coveredFields.length === 1 && config.fields.length === 1) {
+      Object.assign(builtCondition, query[primaryField]);
+    } else {
+      if (startOperator && startValues.length > 0) {
+        builtCondition[startOperator] = { v: startValues.length === 1 ? startValues[0] : startValues };
+      }
+      if (endOperator && endValues.length > 0) {
+        if (startOperator && startValues.length === endValues.length && startValues.every((val, i) => val === endValues[i])) {
+          delete builtCondition[startOperator];
+          builtCondition["primaryEqual"] = { v: startValues.length === 1 ? startValues[0] : startValues };
+        } else {
+          builtCondition[endOperator] = { v: endValues.length === 1 ? endValues[0] : endValues };
+        }
+      }
+      if (Object.keys(builtCondition).length === 0) {
+        Object.assign(builtCondition, query[primaryField] || {});
+      }
+    }
+    let isIndexOrderSupported = false;
+    if (orderByField) {
+      for (let i = 0, len = config.fields.length; i < len; i++) {
+        const field = config.fields[i];
+        if (field === orderByField) {
+          isIndexOrderSupported = true;
+          break;
+        }
+        const cond = query[field];
+        let isExactMatch = false;
+        if (cond !== void 0) {
+          if (typeof cond !== "object" || cond === null) isExactMatch = true;
+          else if ("primaryEqual" in cond || "equal" in cond) isExactMatch = true;
+        }
+        if (!isExactMatch) break;
+      }
+      if (isIndexOrderSupported) {
+        score += 200;
+      }
+    }
+    return {
+      tree: treeTx,
+      condition: builtCondition,
+      field: primaryField,
+      indexName,
+      isFtsMatch: false,
+      score,
+      compositeVerifyFields,
+      coveredFields,
+      isIndexOrderSupported
+    };
+  }
+  /**
+   * FTS 타입 인덱스의 선택도를 평가합니다.
+   * FTSTermCount 통계가 있으면 토큰 빈도 기반 동적 score를 산출합니다.
+   */
+  evaluateFTSCandidate(indexName, config, query, queryFields, treeTx) {
+    const field = config.fields;
+    if (!queryFields.has(field)) return null;
+    const condition = query[field];
+    if (!condition || typeof condition !== "object" || !("match" in condition)) return null;
+    const ftsConfig = this.api.indexManager.getFtsConfig(config);
+    const matchTokens = ftsConfig ? tokenize(condition.match, ftsConfig) : [];
+    const MAX_FTS_SCORE = 400;
+    const MIN_FTS_SCORE = 10;
+    const DEFAULT_FTS_SCORE = 90;
+    let score = DEFAULT_FTS_SCORE;
+    const termCountProvider = this.api.analysisManager.getProvider("fts_term_count");
+    if (termCountProvider && termCountProvider.hasSampleData && ftsConfig && matchTokens.length > 0) {
+      const strategy = ftsConfig.tokenizer === "ngram" ? `${ftsConfig.gramSize}gram` : ftsConfig.tokenizer;
+      const minCount = termCountProvider.getMinTokenCount(field, strategy, matchTokens);
+      if (minCount >= 0) {
+        const sampleSize = termCountProvider.getSampleSize();
+        const selectivityRatio = Math.min(minCount / sampleSize, 1);
+        score = Math.round(MAX_FTS_SCORE * (1 - selectivityRatio) + MIN_FTS_SCORE);
+      }
+    }
+    return {
+      tree: treeTx,
+      condition,
+      field,
+      indexName,
+      isFtsMatch: true,
+      matchTokens,
+      score,
+      compositeVerifyFields: [],
+      coveredFields: [field],
+      isIndexOrderSupported: false
+    };
+  }
+  /**
+   * 실행할 최적의 인덱스를 선택합니다. (최적 드라이버 선택)
+   */
+  async getSelectivityCandidate(query, orderByField) {
+    const queryFields = new Set(Object.keys(query));
+    const candidates = [];
+    for (const [indexName, config] of this.api.indexManager.registeredIndices) {
+      const tree = this.api.trees.get(indexName);
+      if (!tree) continue;
+      if (config.type === "btree") {
+        const treeTx = await tree.createTransaction();
+        const candidate = this.evaluateBTreeCandidate(
+          indexName,
+          config,
+          query,
+          queryFields,
+          treeTx,
+          orderByField
+        );
+        if (candidate) candidates.push(candidate);
+      } else if (config.type === "fts") {
+        const treeTx = await tree.createTransaction();
+        const candidate = this.evaluateFTSCandidate(
+          indexName,
+          config,
+          query,
+          queryFields,
+          treeTx
+        );
+        if (candidate) candidates.push(candidate);
+      }
+    }
+    const rollback = () => {
+      for (const { tree } of candidates) {
+        tree.rollback();
+      }
+    };
+    if (candidates.length === 0) {
+      rollback();
+      return null;
+    }
+    candidates.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      const aConfig = this.api.indexManager.registeredIndices.get(a.indexName);
+      const bConfig = this.api.indexManager.registeredIndices.get(b.indexName);
+      const aFieldCount = aConfig ? Array.isArray(aConfig.fields) ? aConfig.fields.length : 1 : 0;
+      const bFieldCount = bConfig ? Array.isArray(bConfig.fields) ? bConfig.fields.length : 1 : 0;
+      return aFieldCount - bFieldCount;
+    });
+    const driver = candidates[0];
+    const driverCoveredFields = new Set(driver.coveredFields);
+    const nonDriverCandidates = candidates.slice(1).filter((c) => !driverCoveredFields.has(c.field));
+    const others = [];
+    for (let i = 0, len = nonDriverCandidates.length; i < len; i++) {
+      const candidate = nonDriverCandidates[i];
+      let isSubset = false;
+      for (let j = 0, oLen = others.length; j < oLen; j++) {
+        const higher = others[j];
+        if (candidate.coveredFields.every((f) => higher.coveredFields.includes(f))) {
+          isSubset = true;
+          break;
+        }
+      }
+      if (!isSubset) others.push(candidate);
+    }
+    const compositeVerifyConditions = [];
+    for (let i = 0, len = driver.compositeVerifyFields.length; i < len; i++) {
+      const field = driver.compositeVerifyFields[i];
+      if (query[field]) {
+        compositeVerifyConditions.push({ field, condition: query[field] });
+      }
+    }
+    return {
+      driver,
+      others,
+      compositeVerifyConditions,
+      rollback
+    };
+  }
+};
+
+// src/core/QueryManager.ts
+var os = __toESM(require("node:os"));
+
+// src/utils/heap.ts
+var BinaryHeap = class {
+  constructor(comparator) {
+    this.comparator = comparator;
+  }
+  heap = [];
+  get size() {
+    return this.heap.length;
+  }
+  peek() {
+    return this.heap[0];
+  }
+  push(value) {
+    this.heap.push(value);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  pop() {
+    if (this.size === 0) return void 0;
+    const top = this.heap[0];
+    const bottom = this.heap.pop();
+    if (this.size > 0) {
+      this.heap[0] = bottom;
+      this.sinkDown(0);
+    }
+    return top;
+  }
+  /**
+   * Replace the root element with a new value and re-heapify.
+   * Faster than pop() followed by push().
+   */
+  replace(value) {
+    const top = this.heap[0];
+    this.heap[0] = value;
+    this.sinkDown(0);
+    return top;
+  }
+  toArray() {
+    return [...this.heap];
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.comparator(this.heap[index], this.heap[parentIndex]) >= 0) break;
+      [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
+      index = parentIndex;
+    }
+  }
+  sinkDown(index) {
+    while (true) {
+      let smallest = index;
+      const left = 2 * index + 1;
+      const right = 2 * index + 2;
+      if (left < this.size && this.comparator(this.heap[left], this.heap[smallest]) < 0) {
+        smallest = left;
+      }
+      if (right < this.size && this.comparator(this.heap[right], this.heap[smallest]) < 0) {
+        smallest = right;
+      }
+      if (smallest === index) break;
+      [this.heap[index], this.heap[smallest]] = [this.heap[smallest], this.heap[index]];
+      index = smallest;
+    }
+  }
+};
+
+// src/core/QueryManager.ts
+var QueryManager = class {
+  constructor(api, optimizer) {
+    this.api = api;
+    this.optimizer = optimizer;
+  }
+  operatorConverters = {
+    equal: "primaryEqual",
+    notEqual: "primaryNotEqual",
+    lt: "primaryLt",
+    lte: "primaryLte",
+    gt: "primaryGt",
+    gte: "primaryGte",
+    or: "primaryOr",
+    like: "like"
+  };
+  /**
+   * Transforms a query object into a verbose query object
+   */
+  verboseQuery(query) {
+    const result = {};
+    for (const field in query) {
+      const conditions = query[field];
+      let newConditions;
+      if (typeof conditions !== "object" || conditions === null) {
+        newConditions = { primaryEqual: { v: conditions } };
+      } else {
+        newConditions = {};
+        for (const operator in conditions) {
+          const before = operator;
+          const after = this.operatorConverters[before];
+          const v = conditions[before];
+          if (!after) {
+            if (before === "match") {
+              newConditions[before] = v;
+            }
+            continue;
+          }
+          if (before === "or" && Array.isArray(v)) {
+            newConditions[after] = v.map((val) => ({ v: val }));
+          } else if (before === "like") {
+            newConditions[after] = v;
+          } else {
+            newConditions[after] = { v };
+          }
+        }
+      }
+      result[field] = newConditions;
+    }
+    return result;
+  }
+  getFreeMemoryChunkSize() {
+    const freeMem = os.freemem();
+    const safeLimit = freeMem * 0.2;
+    const verySmallChunkSize = safeLimit * 0.05;
+    const smallChunkSize = safeLimit * 0.3;
+    return { verySmallChunkSize, smallChunkSize };
+  }
+  async *applyCandidateByFTSStream(candidate, matchedTokens, filterValues, order) {
+    const keys = /* @__PURE__ */ new Set();
+    for (let i = 0, len = matchedTokens.length; i < len; i++) {
+      const token = matchedTokens[i];
+      for await (const pair of candidate.tree.whereStream(
+        { primaryEqual: { v: token } },
+        { order }
+      )) {
+        const pk = pair[1].k;
+        if (filterValues && !filterValues.has(pk)) continue;
+        if (!keys.has(pk)) {
+          keys.add(pk);
+          yield pk;
+        }
+      }
+    }
+  }
+  applyCandidateStream(candidate, filterValues, order) {
+    return candidate.tree.keysStream(
+      candidate.condition,
+      { filterValues, order }
+    );
+  }
+  async getKeys(query, orderBy, sortOrder = "asc") {
+    const isQueryEmpty = Object.keys(query).length === 0;
+    const normalizedQuery = isQueryEmpty ? { _id: { gte: 0 } } : query;
+    const selectivity = await this.optimizer.getSelectivityCandidate(
+      this.verboseQuery(normalizedQuery),
+      orderBy
+    );
+    if (!selectivity) return new Float64Array(0);
+    const { driver, others, rollback } = selectivity;
+    const useIndexOrder = orderBy === void 0 || driver.isIndexOrderSupported;
+    const candidates = [driver, ...others];
+    let keys = void 0;
+    for (let i = 0, len = candidates.length; i < len; i++) {
+      const candidate = candidates[i];
+      const currentOrder = useIndexOrder ? sortOrder : void 0;
+      if (candidate.isFtsMatch && candidate.matchTokens && candidate.matchTokens.length > 0) {
+        const stream = this.applyCandidateByFTSStream(
+          candidate,
+          candidate.matchTokens,
+          keys,
+          currentOrder
+        );
+        keys = /* @__PURE__ */ new Set();
+        for await (const pk of stream) keys.add(pk);
+      } else {
+        const stream = this.applyCandidateStream(candidate, keys, currentOrder);
+        keys = /* @__PURE__ */ new Set();
+        for await (const pk of stream) keys.add(pk);
+      }
+    }
+    rollback();
+    return new Float64Array(Array.from(keys || []));
+  }
+  async getDriverKeys(query, orderBy, sortOrder = "asc") {
+    const isQueryEmpty = Object.keys(query).length === 0;
+    const normalizedQuery = isQueryEmpty ? { _id: { gte: 0 } } : query;
+    const selectivity = await this.optimizer.getSelectivityCandidate(
+      this.verboseQuery(normalizedQuery),
+      orderBy
+    );
+    if (!selectivity) return null;
+    const { driver, others, compositeVerifyConditions, rollback } = selectivity;
+    const useIndexOrder = orderBy === void 0 || driver.isIndexOrderSupported;
+    const currentOrder = useIndexOrder ? sortOrder : void 0;
+    let keysStream;
+    if (driver.isFtsMatch && driver.matchTokens && driver.matchTokens.length > 0) {
+      keysStream = this.applyCandidateByFTSStream(
+        driver,
+        driver.matchTokens,
+        void 0,
+        currentOrder
+      );
+    } else {
+      keysStream = this.applyCandidateStream(driver, void 0, currentOrder);
+    }
+    return {
+      keysStream,
+      others,
+      compositeVerifyConditions,
+      isDriverOrderByField: useIndexOrder,
+      rollback
+    };
+  }
+  verifyFts(doc, ftsConditions) {
+    const flatDoc = this.api.flattenDocument(doc);
+    for (let i = 0, len = ftsConditions.length; i < len; i++) {
+      const { field, matchTokens } = ftsConditions[i];
+      const docValue = flatDoc[field];
+      if (typeof docValue !== "string") return false;
+      for (let j = 0, jLen = matchTokens.length; j < jLen; j++) {
+        const token = matchTokens[j];
+        if (!docValue.includes(token)) return false;
+      }
+    }
+    return true;
+  }
+  verifyCompositeConditions(doc, conditions) {
+    if (conditions.length === 0) return true;
+    const flatDoc = this.api.flattenDocument(doc);
+    for (let i = 0, len = conditions.length; i < len; i++) {
+      const { field, condition } = conditions[i];
+      const docValue = flatDoc[field];
+      if (docValue === void 0) return false;
+      if (!this.verifyValue(docValue, condition)) return false;
+    }
+    return true;
+  }
+  verifyValue(value, condition) {
+    if (typeof condition !== "object" || condition === null) {
+      return value === condition;
+    }
+    if ("primaryEqual" in condition) {
+      return value === condition.primaryEqual?.v;
+    }
+    if ("primaryNotEqual" in condition) {
+      return value !== condition.primaryNotEqual?.v;
+    }
+    if ("primaryLt" in condition) {
+      return value !== null && condition.primaryLt?.v !== void 0 && value < condition.primaryLt.v;
+    }
+    if ("primaryLte" in condition) {
+      return value !== null && condition.primaryLte?.v !== void 0 && value <= condition.primaryLte.v;
+    }
+    if ("primaryGt" in condition) {
+      return value !== null && condition.primaryGt?.v !== void 0 && value > condition.primaryGt.v;
+    }
+    if ("primaryGte" in condition) {
+      return value !== null && condition.primaryGte?.v !== void 0 && value >= condition.primaryGte.v;
+    }
+    if ("primaryOr" in condition && Array.isArray(condition.primaryOr)) {
+      return condition.primaryOr.some((c) => value === c?.v);
+    }
+    return true;
+  }
+  adjustChunkSize(currentChunkSize, chunkTotalSize) {
+    if (chunkTotalSize <= 0) return currentChunkSize;
+    const { verySmallChunkSize, smallChunkSize } = this.getFreeMemoryChunkSize();
+    if (chunkTotalSize < verySmallChunkSize) return currentChunkSize * 2;
+    if (chunkTotalSize > smallChunkSize) return Math.max(Math.floor(currentChunkSize / 2), 20);
+    return currentChunkSize;
+  }
+  async *processChunkedKeysWithVerify(keysStream, startIdx, initialChunkSize, limit, ftsConditions, compositeVerifyConditions, others, tx) {
+    const verifyOthers = others.filter((o) => !o.isFtsMatch);
+    const isFts = ftsConditions.length > 0;
+    const isCompositeVerify = compositeVerifyConditions.length > 0;
+    const isVerifyOthers = verifyOthers.length > 0;
+    const isInfinityLimit = !isFinite(limit);
+    const isReadQuotaLimited = !isInfinityLimit && // limit이 임의의 유한한 값으로 설정되어 있으며
+    !isCompositeVerify && // 문서를 가져온 후 복합 인덱스 기준으로 2차 필터링할 필요가 없고
+    !isVerifyOthers && // 문서를 가져온 후 다른 인덱스 기준으로 2차 필터링할 필요가 없으며
+    !isFts;
+    let currentChunkSize = isReadQuotaLimited ? limit : initialChunkSize;
+    let chunk = [];
+    let chunkSize = 0;
+    let dropped = 0;
+    const processChunk = async (pks) => {
+      const docs = [];
+      const rawResults = await this.api.selectMany(new Float64Array(pks), false, tx);
+      let chunkTotalSize = 0;
+      for (let j = 0, len = rawResults.length; j < len; j++) {
+        const s = rawResults[j];
+        if (!s) continue;
+        const doc = JSON.parse(s);
+        chunkTotalSize += s.length * 2;
+        if (isFts && !this.verifyFts(doc, ftsConditions)) continue;
+        if (isCompositeVerify && this.verifyCompositeConditions(doc, compositeVerifyConditions) === false) continue;
+        if (isVerifyOthers) {
+          const flatDoc = this.api.flattenDocument(doc);
+          let passed = true;
+          for (let k = 0, kLen = verifyOthers.length; k < kLen; k++) {
+            const other = verifyOthers[k];
+            const coveredFields = other.coveredFields;
+            let fieldValue;
+            if (coveredFields && coveredFields.length > 1) {
+              const values = [];
+              let hasMissing = false;
+              for (let f = 0, fLen = coveredFields.length; f < fLen; f++) {
+                const v = flatDoc[coveredFields[f]];
+                if (v === void 0) {
+                  hasMissing = true;
+                  break;
+                }
+                values.push(v);
+              }
+              if (hasMissing) {
+                passed = false;
+                break;
+              }
+              fieldValue = values;
+            } else {
+              fieldValue = flatDoc[other.field];
+              if (fieldValue === void 0) {
+                passed = false;
+                break;
+              }
+            }
+            const treeValue = { k: doc._id, v: fieldValue };
+            if (!other.tree.verify(treeValue, other.condition)) {
+              passed = false;
+              break;
+            }
+          }
+          if (!passed) continue;
+        }
+        docs.push(doc);
+      }
+      if (!isReadQuotaLimited) {
+        currentChunkSize = this.adjustChunkSize(currentChunkSize, chunkTotalSize);
+      }
+      return docs;
+    };
+    for await (const pk of keysStream) {
+      if (dropped < startIdx) {
+        dropped++;
+        continue;
+      }
+      chunk.push(pk);
+      chunkSize++;
+      if (chunkSize >= currentChunkSize) {
+        const docs = await processChunk(chunk);
+        for (let j = 0, dLen = docs.length; j < dLen; j++) yield docs[j];
+        chunk = [];
+        chunkSize = 0;
+      }
+    }
+    if (chunkSize > 0) {
+      const docs = await processChunk(chunk);
+      for (let j = 0, dLen = docs.length; j < dLen; j++) yield docs[j];
+    }
+  }
+  /**
+   * Count documents from the database that match the query
+   * @param query The query to use
+   * @param tx The transaction to use
+   * @returns The number of documents that match the query
+   */
+  async countDocuments(query, tx) {
+    return this.api.runWithDefault(async (tx2) => {
+      const pks = await this.getKeys(query);
+      return pks.length;
+    }, tx);
+  }
+  selectDocuments(query, options = {}, tx) {
+    for (const field of Object.keys(query)) {
+      if (!this.api.indexedFields.has(field)) {
+        throw new Error(`Query field "${field}" is not indexed. Available indexed fields: ${Array.from(this.api.indexedFields).join(", ")}`);
+      }
+    }
+    const orderBy = options.orderBy;
+    if (orderBy !== void 0 && !this.api.indexedFields.has(orderBy)) {
+      throw new Error(`orderBy field "${orderBy}" is not indexed. Available indexed fields: ${Array.from(this.api.indexedFields).join(", ")}`);
+    }
+    const {
+      limit = Infinity,
+      offset = 0,
+      sortOrder = "asc",
+      orderBy: orderByField
+    } = options;
+    const self = this;
+    const stream = () => this.api.streamWithDefault(async function* (tx2) {
+      const ftsConditions = [];
+      for (const field in query) {
+        const q = query[field];
+        if (q && typeof q === "object" && "match" in q && typeof q.match === "string") {
+          const indexNames = self.api.indexManager.fieldToIndices.get(field) || [];
+          for (const indexName of indexNames) {
+            const config = self.api.indexManager.registeredIndices.get(indexName);
+            if (config && config.type === "fts") {
+              const ftsConfig = self.api.indexManager.getFtsConfig(config);
+              if (ftsConfig) {
+                ftsConditions.push({ field, matchTokens: tokenize(q.match, ftsConfig) });
+              }
+              break;
+            }
+          }
+        }
+      }
+      const driverResult = await self.getDriverKeys(query, orderByField, sortOrder);
+      if (!driverResult) return;
+      const { keysStream, others, compositeVerifyConditions, isDriverOrderByField, rollback } = driverResult;
+      const initialChunkSize = self.api.options.pageSize;
+      try {
+        if (!isDriverOrderByField && orderByField) {
+          const topK = limit === Infinity ? Infinity : offset + limit;
+          let heap = null;
+          if (topK !== Infinity) {
+            heap = new BinaryHeap((a, b) => {
+              const aVal = a[orderByField] ?? a._id;
+              const bVal = b[orderByField] ?? b._id;
+              const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+              return sortOrder === "asc" ? -cmp : cmp;
+            });
+          }
+          const results = [];
+          for await (const doc of self.processChunkedKeysWithVerify(
+            keysStream,
+            0,
+            initialChunkSize,
+            Infinity,
+            ftsConditions,
+            compositeVerifyConditions,
+            others,
+            tx2
+          )) {
+            if (heap) {
+              if (heap.size < topK) heap.push(doc);
+              else {
+                const top = heap.peek();
+                if (top) {
+                  const aVal = doc[orderByField] ?? doc._id;
+                  const bVal = top[orderByField] ?? top._id;
+                  const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+                  if (sortOrder === "asc" ? cmp < 0 : cmp > 0) heap.replace(doc);
+                }
+              }
+            } else {
+              results.push(doc);
+            }
+          }
+          const finalDocs = heap ? heap.toArray() : results;
+          finalDocs.sort((a, b) => {
+            const aVal = a[orderByField] ?? a._id;
+            const bVal = b[orderByField] ?? b._id;
+            const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+            return sortOrder === "asc" ? cmp : -cmp;
+          });
+          const end = limit === Infinity ? void 0 : offset + limit;
+          const limitedResults = finalDocs.slice(offset, end);
+          for (let j = 0, len = limitedResults.length; j < len; j++) {
+            yield limitedResults[j];
+          }
+        } else {
+          const hasFilters = ftsConditions.length > 0 || compositeVerifyConditions.length > 0 || others.length > 0;
+          const startIdx = hasFilters ? 0 : offset;
+          let yieldedCount = 0;
+          let skippedCount = hasFilters ? 0 : offset;
+          for await (const doc of self.processChunkedKeysWithVerify(
+            keysStream,
+            startIdx,
+            initialChunkSize,
+            limit,
+            ftsConditions,
+            compositeVerifyConditions,
+            others,
+            tx2
+          )) {
+            if (skippedCount < offset) {
+              skippedCount++;
+              continue;
+            }
+            if (yieldedCount >= limit) break;
+            yield doc;
+            yieldedCount++;
+          }
+        }
+      } finally {
+        rollback();
+      }
+    }, tx);
+    const drain = async () => {
+      const result = [];
+      for await (const document of stream()) {
+        result.push(document);
+      }
+      return result;
+    };
+    return { stream, drain };
+  }
+};
+
+// src/core/IndexManager.ts
+var import_dataply3 = __toESM(require_cjs());
+
+// src/core/bptree/documentStrategy.ts
+var import_dataply2 = __toESM(require_cjs());
+var DocumentSerializeStrategyAsync = class extends import_dataply2.SerializeStrategyAsync {
+  constructor(order, api, txContext, treeKey) {
+    super(order);
+    this.api = api;
+    this.txContext = txContext;
+    this.treeKey = treeKey;
+  }
+  /**
+   * readHead에서 할당된 headPk를 캐싱하여
+   * writeHead에서 AsyncLocalStorage 컨텍스트 유실 시에도 사용할 수 있도록 함
+   */
+  cachedHeadPk = null;
+  async id(isLeaf) {
+    const tx = this.txContext.get();
+    const pk = await this.api.insertAsOverflow("__BPTREE_NODE_PLACEHOLDER__", false, tx);
+    return pk + "";
+  }
+  async read(id) {
+    const tx = this.txContext.get();
+    const row = await this.api.select(Number(id), false, tx);
+    if (row === null || row === "" || row.startsWith("__BPTREE_")) {
+      throw new Error(`Node not found or empty with ID: ${id}`);
+    }
+    return JSON.parse(row);
+  }
+  async write(id, node) {
+    const tx = this.txContext.get();
+    const json = JSON.stringify(node);
+    await this.api.update(+id, json, tx);
+  }
+  async delete(id) {
+    const tx = this.txContext.get();
+    await this.api.delete(+id, false, tx);
+  }
+  async readHead() {
+    const tx = this.txContext.get();
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    const indexInfo = metadata.indices[this.treeKey];
+    if (!indexInfo) return null;
+    const headPk = indexInfo[0];
+    if (headPk === -1) {
+      const pk = await this.api.insertAsOverflow("__BPTREE_HEAD_PLACEHOLDER__", false, tx);
+      metadata.indices[this.treeKey][0] = pk;
+      await this.api.updateDocumentInnerMetadata(metadata, tx);
+      this.cachedHeadPk = pk;
+      return null;
+    }
+    this.cachedHeadPk = headPk;
+    const row = await this.api.select(headPk, false, tx);
+    if (row === null || row === "" || row.startsWith("__BPTREE_")) return null;
+    return JSON.parse(row);
+  }
+  async writeHead(head) {
+    const tx = this.txContext.get();
+    let headPk = this.cachedHeadPk;
+    if (headPk === null) {
+      const metadata = await this.api.getDocumentInnerMetadata(tx);
+      const indexInfo = metadata.indices[this.treeKey];
+      if (!indexInfo) {
+        throw new Error(`Index info not found for tree: ${this.treeKey}. Initialization should be handled outside.`);
+      }
+      headPk = indexInfo[0];
+    }
+    const json = JSON.stringify(head);
+    await this.api.update(headPk, json, tx);
+  }
+};
+
+// src/core/IndexManager.ts
+var IndexManager = class {
+  constructor(api) {
+    this.api = api;
+    this.trees = /* @__PURE__ */ new Map();
+    this.indexedFields = /* @__PURE__ */ new Set(["_id"]);
+  }
+  indices = {};
+  trees = /* @__PURE__ */ new Map();
+  indexedFields;
+  /**
+   * Registered indices via createIndex() (before init)
+   * Key: index name, Value: index configuration
+   */
+  pendingCreateIndices = /* @__PURE__ */ new Map();
+  /**
+   * Resolved index configurations after init.
+   * Key: index name, Value: index config (from metadata)
+   */
+  registeredIndices = /* @__PURE__ */ new Map();
+  /**
+   * Maps field name → index names that cover this field.
+   * Used for query resolution.
+   */
+  fieldToIndices = /* @__PURE__ */ new Map();
+  pendingBackfillFields = [];
+  /**
+   * Validate and apply indices from DB metadata and pending indices.
+   * Called during database initialization.
+   */
+  async initializeIndices(metadata, isNewlyCreated, tx) {
+    const targetIndices = /* @__PURE__ */ new Map([
+      ["_id", { type: "btree", fields: ["_id"] }]
+    ]);
+    for (const [name, info] of Object.entries(metadata.indices)) {
+      targetIndices.set(name, info[1]);
+    }
+    for (const [name, option] of this.pendingCreateIndices) {
+      const config = this.toIndexMetaConfig(option);
+      targetIndices.set(name, config);
+    }
+    const backfillTargets = [];
+    let isMetadataChanged = false;
+    for (const [indexName, config] of targetIndices) {
+      const existingIndex = metadata.indices[indexName];
+      if (!existingIndex) {
+        metadata.indices[indexName] = [-1, config];
+        isMetadataChanged = true;
+        if (!isNewlyCreated) {
+          backfillTargets.push(indexName);
+        }
+      } else {
+        const [_pk, existingConfig] = existingIndex;
+        if (JSON.stringify(existingConfig) !== JSON.stringify(config)) {
+          metadata.indices[indexName] = [_pk, config];
+          isMetadataChanged = true;
+          if (!isNewlyCreated) {
+            backfillTargets.push(indexName);
+          }
+        }
+      }
+    }
+    if (isMetadataChanged) {
+      await this.api.updateDocumentInnerMetadata(metadata, tx);
+    }
+    this.indices = metadata.indices;
+    this.registeredIndices = /* @__PURE__ */ new Map();
+    this.fieldToIndices = /* @__PURE__ */ new Map();
+    for (const [indexName, config] of targetIndices) {
+      this.registeredIndices.set(indexName, config);
+      const fields = this.getFieldsFromConfig(config);
+      for (const field of fields) {
+        this.indexedFields.add(field);
+        if (!this.fieldToIndices.has(field)) {
+          this.fieldToIndices.set(field, []);
+        }
+        this.fieldToIndices.get(field).push(indexName);
+      }
+    }
+    for (const indexName of targetIndices.keys()) {
+      if (metadata.indices[indexName]) {
+        const tree = new import_dataply3.BPTreeAsync(
+          new DocumentSerializeStrategyAsync(
+            this.api.rowTableEngine.order,
+            this.api,
+            this.api.txContext,
+            indexName
+          ),
+          this.api.comparator
+        );
+        await tree.init();
+        this.trees.set(indexName, tree);
+      }
+    }
+    this.pendingBackfillFields = backfillTargets;
+    return isMetadataChanged;
+  }
+  /**
+   * Register an index. If called before init(), queues it.
+   */
+  async registerIndex(name, option, tx) {
+    if (!this.api.isDocInitialized) {
+      this.pendingCreateIndices.set(name, option);
+      return;
+    }
+    await this.registerIndexRuntime(name, option, tx);
+  }
+  /**
+   * Register an index at runtime (after init).
+   */
+  async registerIndexRuntime(name, option, tx) {
+    const config = this.toIndexMetaConfig(option);
+    if (this.registeredIndices.has(name)) {
+      throw new Error(`Index "${name}" already exists.`);
+    }
+    await this.api.runWithDefaultWrite(async (tx2) => {
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
+      metadata.indices[name] = [-1, config];
+      await this.api.updateDocumentInnerMetadata(metadata, tx2);
+      this.indices = metadata.indices;
+      this.registeredIndices.set(name, config);
+      const fields = this.getFieldsFromConfig(config);
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        this.indexedFields.add(field);
+        if (!this.fieldToIndices.has(field)) {
+          this.fieldToIndices.set(field, []);
+        }
+        this.fieldToIndices.get(field).push(name);
+      }
+      const tree = new import_dataply3.BPTreeAsync(
         new DocumentSerializeStrategyAsync(
-          this.rowTableEngine.order,
-          this,
-          this.txContext,
+          this.api.rowTableEngine.order,
+          this.api,
+          this.api.txContext,
           name
         ),
-        this.comparator
+        this.api.comparator
       );
       await tree.init();
       this.trees.set(name, tree);
@@ -10779,26 +11454,23 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
   }
   /**
    * Drop (remove) a named index.
-   * Removes the index from metadata, in-memory maps, and trees.
-   * The '_id' index cannot be dropped.
-   * @param name The name of the index to drop
    */
   async dropIndex(name, tx) {
     if (name === "_id") {
       throw new Error('Cannot drop the "_id" index.');
     }
-    if (!this._initialized) {
+    if (!this.api.isDocInitialized) {
       this.pendingCreateIndices.delete(name);
       return;
     }
     if (!this.registeredIndices.has(name)) {
       throw new Error(`Index "${name}" does not exist.`);
     }
-    await this.runWithDefaultWrite(async (tx2) => {
+    await this.api.runWithDefaultWrite(async (tx2) => {
       const config = this.registeredIndices.get(name);
-      const metadata = await this.getDocumentInnerMetadata(tx2);
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
       delete metadata.indices[name];
-      await this.updateDocumentInnerMetadata(metadata, tx2);
+      await this.api.updateDocumentInnerMetadata(metadata, tx2);
       this.indices = metadata.indices;
       this.registeredIndices.delete(name);
       const fields = this.getFieldsFromConfig(config);
@@ -10817,7 +11489,107 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
           }
         }
       }
-      this.trees.delete(name);
+      this.trees.delete(name);
+    }, tx);
+  }
+  /**
+   * Backfill indices for newly created indices after data was inserted.
+   */
+  async backfillIndices(tx) {
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      if (this.pendingBackfillFields.length === 0) {
+        return 0;
+      }
+      const backfillTargets = this.pendingBackfillFields;
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
+      if (metadata.lastId === 0) {
+        return 0;
+      }
+      let indexTxMap = {};
+      for (const indexName of backfillTargets) {
+        const tree = this.trees.get(indexName);
+        if (tree && indexName !== "_id") {
+          indexTxMap[indexName] = await tree.createTransaction();
+        }
+      }
+      let backfilledCount = 0;
+      let chunkCount = 0;
+      const CHUNK_SIZE = 1e3;
+      const idTree = this.trees.get("_id");
+      if (!idTree) {
+        throw new Error("ID tree not found");
+      }
+      const stream = idTree.whereStream({
+        primaryGte: { v: 0 }
+      });
+      for await (const [k, complexValue] of stream) {
+        const doc = await this.api.getDocument(k, tx2);
+        if (!doc) continue;
+        const flatDoc = this.api.flattenDocument(doc);
+        for (let i = 0, len = backfillTargets.length; i < len; i++) {
+          const indexName = backfillTargets[i];
+          if (!(indexName in indexTxMap)) continue;
+          const config = this.registeredIndices.get(indexName);
+          if (!config) continue;
+          const btx = indexTxMap[indexName];
+          if (config.type === "fts") {
+            const primaryField = this.getPrimaryField(config);
+            const v = flatDoc[primaryField];
+            if (v === void 0 || typeof v !== "string") continue;
+            const ftsConfig = this.getFtsConfig(config);
+            const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
+            const batchInsertData = [];
+            for (let i2 = 0, len2 = tokens.length; i2 < len2; i2++) {
+              const token = tokens[i2];
+              const keyToInsert = this.getTokenKey(k, token);
+              const entry = { k, v: token };
+              batchInsertData.push([keyToInsert, entry]);
+            }
+            await btx.batchInsert(batchInsertData);
+          } else {
+            const indexVal = this.getIndexValue(config, flatDoc);
+            if (indexVal === void 0) continue;
+            const entry = { k, v: indexVal };
+            const batchInsertData = [[k, entry]];
+            await btx.batchInsert(batchInsertData);
+          }
+        }
+        backfilledCount++;
+        chunkCount++;
+        if (chunkCount >= CHUNK_SIZE) {
+          try {
+            for (const btx of Object.values(indexTxMap)) {
+              await btx.commit();
+            }
+          } catch (err) {
+            for (const btx of Object.values(indexTxMap)) {
+              await btx.rollback();
+            }
+            throw err;
+          }
+          for (const indexName of backfillTargets) {
+            const tree = this.trees.get(indexName);
+            if (tree && indexName !== "_id") {
+              indexTxMap[indexName] = await tree.createTransaction();
+            }
+          }
+          chunkCount = 0;
+        }
+      }
+      if (chunkCount > 0) {
+        try {
+          for (const btx of Object.values(indexTxMap)) {
+            await btx.commit();
+          }
+        } catch (err) {
+          for (const btx of Object.values(indexTxMap)) {
+            await btx.rollback();
+          }
+          throw err;
+        }
+      }
+      this.pendingBackfillFields = [];
+      return backfilledCount;
     }, tx);
   }
   /**
@@ -10880,9 +11652,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     return [];
   }
   /**
-   * Get the primary field of an index (the field used as tree key).
-   * For btree: first field in fields array.
-   * For fts: the single field.
+   * Get the primary field of an index.
    */
   getPrimaryField(config) {
     if (config.type === "btree") {
@@ -10891,11 +11661,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     return config.fields;
   }
   /**
-   * 인덱스 config에 따라 B+tree에 저장할 v 값을 생성합니다.
-   * - 단일 필드 btree: Primitive (단일 값)
-   * - 복합 필드 btree: Primitive[] (필드 순서대로 배열)
-   * - fts: 별도 처리 (이 메서드 사용 안 함)
-   * @returns undefined면 해당 문서에 필수 필드가 없으므로 인덱싱 스킵
+   * Create B+Tree value string for indexing a document
    */
   getIndexValue(config, flatDoc) {
     if (config.type !== "btree") return void 0;
@@ -10912,7 +11678,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     return values;
   }
   /**
-   * Get FTSConfig from IndexMetaConfig (for tokenizer compatibility).
+   * Get FTSConfig from IndexMetaConfig
    */
   getFtsConfig(config) {
     if (config.type !== "fts") return null;
@@ -10921,171 +11687,265 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     }
     return { type: "fts", tokenizer: "whitespace" };
   }
-  async getDocument(pk, tx) {
-    return this.runWithDefault(async (tx2) => {
-      const row = await this.select(pk, false, tx2);
-      if (!row) {
-        throw new Error(`Document not found with PK: ${pk}`);
+  getTokenKey(pk, token) {
+    return pk + ":" + token;
+  }
+};
+
+// src/utils/catchPromise.ts
+async function catchPromise(promise) {
+  return promise.then((res) => [void 0, res]).catch((reason) => [reason]);
+}
+
+// src/core/MutationManager.ts
+var MutationManager = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async insertDocumentInternal(document, tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    const id = ++metadata.lastId;
+    await this.api.updateDocumentInnerMetadata(metadata, tx);
+    const dataplyDocument = Object.assign({
+      _id: id
+    }, document);
+    const pk = await this.api.insert(JSON.stringify(dataplyDocument), true, tx);
+    return {
+      pk,
+      id,
+      document: dataplyDocument
+    };
+  }
+  async insertSingleDocument(document, tx) {
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      const { pk: dpk, document: dataplyDocument } = await this.insertDocumentInternal(document, tx2);
+      const flattenDocument = this.api.flattenDocument(dataplyDocument);
+      for (const [indexName, config] of this.api.indexManager.registeredIndices) {
+        const tree = this.api.trees.get(indexName);
+        if (!tree) continue;
+        if (config.type === "fts") {
+          const primaryField = this.api.indexManager.getPrimaryField(config);
+          const v = flattenDocument[primaryField];
+          if (v === void 0 || typeof v !== "string") continue;
+          const ftsConfig = this.api.indexManager.getFtsConfig(config);
+          const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
+          for (let i = 0, len = tokens.length; i < len; i++) {
+            const token = tokens[i];
+            const keyToInsert = this.api.indexManager.getTokenKey(dpk, token);
+            const [error] = await catchPromise(tree.insert(keyToInsert, { k: dpk, v: token }));
+            if (error) throw error;
+          }
+        } else {
+          const indexVal = this.api.indexManager.getIndexValue(config, flattenDocument);
+          if (indexVal === void 0) continue;
+          const [error] = await catchPromise(tree.insert(dpk, { k: dpk, v: indexVal }));
+          if (error) throw error;
+        }
       }
-      return JSON.parse(row);
+      await this.api.analysisManager.notifyInsert([flattenDocument], tx2);
+      return dataplyDocument._id;
     }, tx);
   }
-  /**
-   * Backfill indices for newly created indices after data was inserted.
-   * This method should be called after `init()`.
-   *
-   * @returns Number of documents that were backfilled
-   */
-  async backfillIndices(tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      if (this.pendingBackfillFields.length === 0) {
-        return 0;
-      }
-      const backfillTargets = this.pendingBackfillFields;
-      const metadata = await this.getDocumentInnerMetadata(tx2);
-      if (metadata.lastId === 0) {
-        return 0;
-      }
-      let indexTxMap = {};
-      for (const indexName of backfillTargets) {
-        const tree = this.trees.get(indexName);
-        if (tree && indexName !== "_id") {
-          indexTxMap[indexName] = await tree.createTransaction();
-        }
+  async insertBatchDocuments(documents, tx) {
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
+      const startId = metadata.lastId + 1;
+      metadata.lastId += documents.length;
+      await this.api.updateDocumentInnerMetadata(metadata, tx2);
+      const ids = [];
+      const dataplyDocuments = [];
+      const flattenedData = [];
+      for (let i = 0, len = documents.length; i < len; i++) {
+        const id = startId + i;
+        const dataplyDocument = Object.assign({
+          _id: id
+        }, documents[i]);
+        const stringified = JSON.stringify(dataplyDocument);
+        dataplyDocuments.push(stringified);
+        const flattenDocument = this.api.flattenDocument(dataplyDocument);
+        flattenedData.push({ pk: -1, data: flattenDocument });
+        ids.push(id);
       }
-      let backfilledCount = 0;
-      let chunkCount = 0;
-      const CHUNK_SIZE = 1e3;
-      const idTree = this.trees.get("_id");
-      if (!idTree) {
-        throw new Error("ID tree not found");
+      const pks = await this.api.insertBatch(dataplyDocuments, true, tx2);
+      for (let i = 0, len = pks.length; i < len; i++) {
+        flattenedData[i].pk = pks[i];
       }
-      const stream = idTree.whereStream({
-        primaryGte: { v: 0 }
-      });
-      for await (const [k, complexValue] of stream) {
-        const doc = await this.getDocument(k, tx2);
-        if (!doc) continue;
-        const flatDoc = this.flattenDocument(doc);
-        for (let i = 0, len = backfillTargets.length; i < len; i++) {
-          const indexName = backfillTargets[i];
-          if (!(indexName in indexTxMap)) continue;
-          const config = this.registeredIndices.get(indexName);
-          if (!config) continue;
-          const btx = indexTxMap[indexName];
-          if (config.type === "fts") {
-            const primaryField = this.getPrimaryField(config);
-            const v = flatDoc[primaryField];
+      for (const [indexName, config] of this.api.indexManager.registeredIndices) {
+        const tree = this.api.trees.get(indexName);
+        if (!tree) continue;
+        const treeTx = await tree.createTransaction();
+        const batchInsertData = [];
+        if (config.type === "fts") {
+          const primaryField = this.api.indexManager.getPrimaryField(config);
+          const ftsConfig = this.api.indexManager.getFtsConfig(config);
+          for (let i = 0, len = flattenedData.length; i < len; i++) {
+            const item = flattenedData[i];
+            const v = item.data[primaryField];
             if (v === void 0 || typeof v !== "string") continue;
-            const ftsConfig = this.getFtsConfig(config);
             const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
-            const batchInsertData = [];
-            for (let i2 = 0, len2 = tokens.length; i2 < len2; i2++) {
-              const token = tokens[i2];
-              const keyToInsert = this.getTokenKey(k, token);
-              const entry = { k, v: token };
-              batchInsertData.push([keyToInsert, entry]);
+            for (let j = 0, tLen = tokens.length; j < tLen; j++) {
+              const token = tokens[j];
+              batchInsertData.push([this.api.indexManager.getTokenKey(item.pk, token), { k: item.pk, v: token }]);
             }
-            await btx.batchInsert(batchInsertData);
-          } else {
-            const indexVal = this.getIndexValue(config, flatDoc);
+          }
+        } else {
+          for (let i = 0, len = flattenedData.length; i < len; i++) {
+            const item = flattenedData[i];
+            const indexVal = this.api.indexManager.getIndexValue(config, item.data);
             if (indexVal === void 0) continue;
-            const entry = { k, v: indexVal };
-            const batchInsertData = [[k, entry]];
-            await btx.batchInsert(batchInsertData);
+            batchInsertData.push([item.pk, { k: item.pk, v: indexVal }]);
           }
         }
-        backfilledCount++;
-        chunkCount++;
-        if (chunkCount >= CHUNK_SIZE) {
-          try {
-            for (const btx of Object.values(indexTxMap)) {
-              await btx.commit();
-            }
-          } catch (err) {
-            for (const btx of Object.values(indexTxMap)) {
-              await btx.rollback();
+        const [error] = await catchPromise(treeTx.batchInsert(batchInsertData));
+        if (error) {
+          throw error;
+        }
+        const res = await treeTx.commit();
+        if (!res.success) {
+          throw res.error;
+        }
+      }
+      const flatDocs = [];
+      for (let i = 0, len = flattenedData.length; i < len; i++) {
+        flatDocs.push(flattenedData[i].data);
+      }
+      await this.api.analysisManager.notifyInsert(flatDocs, tx2);
+      return ids;
+    }, tx);
+  }
+  async updateInternal(query, computeUpdatedDoc, tx) {
+    const pks = await this.api.queryManager.getKeys(query);
+    let updatedCount = 0;
+    const updatePairs = [];
+    const treeTxs = /* @__PURE__ */ new Map();
+    for (const [indexName, tree] of this.api.trees) {
+      treeTxs.set(indexName, await tree.createTransaction());
+    }
+    treeTxs.delete("_id");
+    for (let i = 0, len = pks.length; i < len; i++) {
+      const pk = pks[i];
+      const doc = await this.api.getDocument(pk, tx);
+      if (!doc) continue;
+      const updatedDoc = computeUpdatedDoc(doc);
+      const oldFlatDoc = this.api.flattenDocument(doc);
+      const newFlatDoc = this.api.flattenDocument(updatedDoc);
+      for (const [indexName, treeTx] of treeTxs) {
+        const config = this.api.indexManager.registeredIndices.get(indexName);
+        if (!config) continue;
+        if (config.type === "fts") {
+          const primaryField = this.api.indexManager.getPrimaryField(config);
+          const oldV = oldFlatDoc[primaryField];
+          const newV = newFlatDoc[primaryField];
+          if (oldV === newV) continue;
+          const ftsConfig = this.api.indexManager.getFtsConfig(config);
+          if (typeof oldV === "string") {
+            const oldTokens = ftsConfig ? tokenize(oldV, ftsConfig) : [oldV];
+            for (let j = 0, jLen = oldTokens.length; j < jLen; j++) {
+              await treeTx.delete(this.api.indexManager.getTokenKey(pk, oldTokens[j]), { k: pk, v: oldTokens[j] });
             }
-            throw err;
           }
-          for (const indexName of backfillTargets) {
-            const tree = this.trees.get(indexName);
-            if (tree && indexName !== "_id") {
-              indexTxMap[indexName] = await tree.createTransaction();
+          if (typeof newV === "string") {
+            const newTokens = ftsConfig ? tokenize(newV, ftsConfig) : [newV];
+            const batchInsertData = [];
+            for (let j = 0, jLen = newTokens.length; j < jLen; j++) {
+              batchInsertData.push([this.api.indexManager.getTokenKey(pk, newTokens[j]), { k: pk, v: newTokens[j] }]);
             }
+            await treeTx.batchInsert(batchInsertData);
           }
-          chunkCount = 0;
-        }
-      }
-      if (chunkCount > 0) {
-        try {
-          for (const btx of Object.values(indexTxMap)) {
-            await btx.commit();
+        } else {
+          const oldIndexVal = this.api.indexManager.getIndexValue(config, oldFlatDoc);
+          const newIndexVal = this.api.indexManager.getIndexValue(config, newFlatDoc);
+          if (JSON.stringify(oldIndexVal) === JSON.stringify(newIndexVal)) continue;
+          if (oldIndexVal !== void 0) {
+            await treeTx.delete(pk, { k: pk, v: oldIndexVal });
           }
-        } catch (err) {
-          for (const btx of Object.values(indexTxMap)) {
-            await btx.rollback();
+          if (newIndexVal !== void 0) {
+            await treeTx.batchInsert([[pk, { k: pk, v: newIndexVal }]]);
           }
-          throw err;
         }
       }
-      this.pendingBackfillFields = [];
-      return backfilledCount;
-    }, tx);
-  }
-  createDocumentInnerMetadata(indices) {
-    return {
-      magicString: "document-dataply",
-      version: 1,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      lastId: 0,
-      schemeVersion: 0,
-      indices
-    };
-  }
-  async initializeDocumentFile(tx) {
-    const metadata = await this.select(1, false, tx);
-    if (metadata) {
-      throw new Error("Document metadata already exists");
+      updatePairs.push({ oldDocument: oldFlatDoc, newDocument: newFlatDoc });
+      await this.api.update(pk, JSON.stringify(updatedDoc), tx);
+      updatedCount++;
     }
-    const metaObj = this.createDocumentInnerMetadata({
-      _id: [-1, { type: "btree", fields: ["_id"] }]
-    });
-    await this.insertAsOverflow(JSON.stringify(metaObj), false, tx);
-  }
-  async verifyDocumentFile(tx) {
-    const row = await this.select(1, false, tx);
-    if (!row) {
-      return false;
+    for (const [indexName, treeTx] of treeTxs) {
+      const result = await treeTx.commit();
+      if (!result.success) {
+        for (const rollbackTx of treeTxs.values()) {
+          rollbackTx.rollback();
+        }
+        throw result.error;
+      }
     }
-    const data = JSON.parse(row);
-    return data.magicString === "document-dataply" && data.version === 1;
+    await this.api.analysisManager.notifyUpdate(updatePairs, tx);
+    return updatedCount;
+  }
+  async fullUpdate(query, newRecord, tx) {
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      return this.updateInternal(query, (doc) => {
+        const newDoc = typeof newRecord === "function" ? newRecord(doc) : newRecord;
+        return { _id: doc._id, ...newDoc };
+      }, tx2);
+    }, tx);
+  }
+  async partialUpdate(query, newRecord, tx) {
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      return this.updateInternal(query, (doc) => {
+        const partialUpdateContent = typeof newRecord === "function" ? newRecord(doc) : newRecord;
+        const finalUpdate = { ...partialUpdateContent };
+        delete finalUpdate._id;
+        return { ...doc, ...finalUpdate };
+      }, tx2);
+    }, tx);
   }
-  flatten(obj, parentKey = "", result = {}) {
-    for (const key in obj) {
-      const newKey = parentKey ? `${parentKey}.${key}` : key;
-      if (typeof obj[key] === "object" && obj[key] !== null) {
-        this.flatten(obj[key], newKey, result);
-      } else {
-        result[newKey] = obj[key];
+  async deleteDocuments(query, tx) {
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      const pks = await this.api.queryManager.getKeys(query);
+      let deletedCount = 0;
+      const deletedFlatDocs = [];
+      for (let i = 0, len = pks.length; i < len; i++) {
+        const pk = pks[i];
+        const doc = await this.api.getDocument(pk, tx2);
+        if (!doc) continue;
+        const flatDoc = this.api.flattenDocument(doc);
+        for (const [indexName, tree] of this.api.trees) {
+          const config = this.api.indexManager.registeredIndices.get(indexName);
+          if (!config) continue;
+          if (config.type === "fts") {
+            const primaryField = this.api.indexManager.getPrimaryField(config);
+            const v = flatDoc[primaryField];
+            if (v === void 0 || typeof v !== "string") continue;
+            const ftsConfig = this.api.indexManager.getFtsConfig(config);
+            const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
+            for (let j = 0, jLen = tokens.length; j < jLen; j++) {
+              await tree.delete(this.api.indexManager.getTokenKey(pk, tokens[j]), { k: pk, v: tokens[j] });
+            }
+          } else {
+            const indexVal = this.api.indexManager.getIndexValue(config, flatDoc);
+            if (indexVal === void 0) continue;
+            await tree.delete(pk, { k: pk, v: indexVal });
+          }
+        }
+        deletedFlatDocs.push(flatDoc);
+        await this.api.delete(pk, true, tx2);
+        deletedCount++;
       }
-    }
-    return result;
+      await this.api.analysisManager.notifyDelete(deletedFlatDocs, tx2);
+      return deletedCount;
+    }, tx);
   }
-  /**
-   * returns flattened document
-   * @param document
-   * @returns
-   */
-  flattenDocument(document) {
-    return this.flatten(document, "", {});
+};
+
+// src/core/MetadataManager.ts
+var MetadataManager = class {
+  constructor(api) {
+    this.api = api;
   }
   async getDocumentMetadata(tx) {
-    const metadata = await this.getMetadata(tx);
+    const metadata = await this.api.getMetadata(tx);
     const innerMetadata = await this.getDocumentInnerMetadata(tx);
     const indices = [];
-    for (const name of this.registeredIndices.keys()) {
+    for (const name of this.api.indexManager.registeredIndices.keys()) {
       if (name !== "_id") {
         indices.push(name);
       }
@@ -11100,24 +11960,17 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     };
   }
   async getDocumentInnerMetadata(tx) {
-    const row = await this.select(1, false, tx);
+    const row = await this.api.select(1, false, tx);
     if (!row) {
       throw new Error("Document metadata not found");
     }
     return JSON.parse(row);
   }
   async updateDocumentInnerMetadata(metadata, tx) {
-    await this.update(1, JSON.stringify(metadata), tx);
+    await this.api.update(1, JSON.stringify(metadata), tx);
   }
-  /**
-   * Run a migration if the current schemeVersion is lower than the target version.
-   * After the callback completes, schemeVersion is updated to the target version.
-   * @param version The target scheme version
-   * @param callback The migration callback
-   * @param tx Optional transaction
-   */
   async migration(version, callback, tx) {
-    await this.runWithDefaultWrite(async (tx2) => {
+    await this.api.runWithDefaultWrite(async (tx2) => {
       const innerMetadata = await this.getDocumentInnerMetadata(tx2);
       const currentVersion = innerMetadata.schemeVersion ?? 0;
       if (currentVersion < version) {
@@ -11129,821 +11982,644 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       }
     }, tx);
   }
-  /**
-   * Transforms a query object into a verbose query object
-   * @param query The query object to transform
-   * @returns The verbose query object
-   */
-  verboseQuery(query) {
-    const result = {};
-    for (const field in query) {
-      const conditions = query[field];
-      let newConditions;
-      if (typeof conditions !== "object" || conditions === null) {
-        newConditions = { primaryEqual: { v: conditions } };
+};
+
+// src/core/DocumentFormatter.ts
+var DocumentFormatter = class {
+  flattenInternal(obj, parentKey = "", result = {}) {
+    for (const key in obj) {
+      const newKey = parentKey ? `${parentKey}.${key}` : key;
+      if (typeof obj[key] === "object" && obj[key] !== null) {
+        this.flattenInternal(obj[key], newKey, result);
       } else {
-        newConditions = {};
-        for (const operator in conditions) {
-          const before = operator;
-          const after = this.operatorConverters[before];
-          const v = conditions[before];
-          if (!after) {
-            if (before === "match") {
-              newConditions[before] = v;
-            }
-            continue;
-          }
-          if (before === "or" && Array.isArray(v)) {
-            newConditions[after] = v.map((val) => ({ v: val }));
-          } else if (before === "like") {
-            newConditions[after] = v;
-          } else {
-            newConditions[after] = { v };
-          }
-        }
+        result[newKey] = obj[key];
       }
-      result[field] = newConditions;
     }
     return result;
   }
+  flattenDocument(document) {
+    return this.flattenInternal(document, "", {});
+  }
+};
+
+// src/core/AnalysisProvider.ts
+var AnalysisProvider = class {
+  constructor(api) {
+    this.api = api;
+  }
+  /** Overflow row PK assigned by AnalysisManager during initialization. */
+  storageKey = -1;
+};
+
+// src/core/RealtimeAnalysisProvider.ts
+var RealtimeAnalysisProvider = class extends AnalysisProvider {
+};
+
+// src/core/IntervalAnalysisProvider.ts
+var IntervalAnalysisProvider = class extends AnalysisProvider {
   /**
-   * B-Tree 타입 인덱스의 선택도를 평가하고 트리에 부여할 조건을 산출합니다.
-   * 필드 매칭 여부를 검사하고, 연속된(Prefix) 조건에 대해 점수를 부여하며 Start/End 바운드를 구성합니다.
-   * 
-   * @param indexName 평가할 인덱스의 이름 (예: idx_nickname_createdat)
-   * @param config 등록된 인덱스의 설정 객체
-   * @param query 쿼리 객체
-   * @param queryFields 쿼리에 포함된 필드 목록 집합
-   * @param treeTx 조회를 수행할 B-Tree 트랜잭션 객체
-   * @param orderByField 정렬에 사용할 필드명 (옵션)
-   * @returns B-Tree 인덱스 후보 정보 (조건, 점수, 커버된 필드 등), 적합하지 않으면 null
+   * Sample random documents from the entire dataset.
+   * Fetches only PK index, then reads only the selected documents from disk.
+   * @param sampleOptions Sampling strategy — either `{ rate }` or `{ count }`
+   * @param tx Optional transaction
+   * @returns Randomly selected documents
    */
-  evaluateBTreeCandidate(indexName, config, query, queryFields, treeTx, orderByField) {
-    const primaryField = config.fields[0];
-    if (!queryFields.has(primaryField)) return null;
-    const builtCondition = {};
-    let score = 0;
-    let isConsecutive = true;
-    const coveredFields = [];
-    const compositeVerifyFields = [];
-    const startValues = [];
-    const endValues = [];
-    let startOperator = null;
-    let endOperator = null;
-    for (let i = 0, len = config.fields.length; i < len; i++) {
-      const field = config.fields[i];
-      if (!queryFields.has(field)) {
-        isConsecutive = false;
-        continue;
+  async sample(sampleOptions, tx) {
+    const pks = await this.api.queryManager.getKeys({});
+    const total = pks.length;
+    if (total === 0) return [];
+    const k = "rate" in sampleOptions && sampleOptions.rate != null ? Math.ceil(total * Math.min(Math.max(sampleOptions.rate, 0), 1)) : sampleOptions.count;
+    const sampleCount = Math.min(Math.max(k, 0), total);
+    if (sampleCount === 0) return [];
+    for (let i = 0; i < sampleCount; i++) {
+      const j = i + Math.floor(Math.random() * (total - i));
+      const tmp = pks[i];
+      pks[i] = pks[j];
+      pks[j] = tmp;
+    }
+    const selectedPks = pks.slice(0, sampleCount);
+    const rawResults = await this.api.selectMany(selectedPks, false, tx);
+    const docs = [];
+    for (let i = 0, len = rawResults.length; i < len; i++) {
+      const raw = rawResults[i];
+      if (raw) docs.push(JSON.parse(raw));
+    }
+    return docs;
+  }
+};
+
+// src/core/analysis/FTSTermCount.ts
+var FTSTermCount = class extends IntervalAnalysisProvider {
+  name = "fts_term_count";
+  termCount = {};
+  sampleSize = 0;
+  async serialize(tx) {
+    const docs = await this.sample({ count: 1e3 }, tx);
+    this.termCount = {};
+    this.sampleSize = docs.length;
+    if (docs.length === 0) return JSON.stringify({ _sampleSize: 0 });
+    const ftsIndices = /* @__PURE__ */ new Map();
+    for (const [indexName, config] of this.api.indexManager.registeredIndices) {
+      if (config.type === "fts") {
+        ftsIndices.set(indexName, config);
       }
-      coveredFields.push(field);
-      score += 1;
-      if (isConsecutive) {
-        const cond = query[field];
-        if (cond !== void 0) {
-          let isBounded = false;
-          if (typeof cond !== "object" || cond === null) {
-            score += 100;
-            startValues.push(cond);
-            endValues.push(cond);
-            startOperator = "primaryGte";
-            endOperator = "primaryLte";
-            isBounded = true;
-          } else if ("primaryEqual" in cond || "equal" in cond) {
-            const val = cond.primaryEqual?.v ?? cond.equal?.v ?? cond.primaryEqual ?? cond.equal;
-            score += 100;
-            startValues.push(val);
-            endValues.push(val);
-            startOperator = "primaryGte";
-            endOperator = "primaryLte";
-            isBounded = true;
-          } else if ("primaryGte" in cond || "gte" in cond) {
-            const val = cond.primaryGte?.v ?? cond.gte?.v ?? cond.primaryGte ?? cond.gte;
-            score += 50;
-            isConsecutive = false;
-            startValues.push(val);
-            startOperator = "primaryGte";
-            if (endValues.length > 0) endOperator = "primaryLte";
-            isBounded = true;
-          } else if ("primaryGt" in cond || "gt" in cond) {
-            const val = cond.primaryGt?.v ?? cond.gt?.v ?? cond.primaryGt ?? cond.gt;
-            score += 50;
-            isConsecutive = false;
-            startValues.push(val);
-            startOperator = "primaryGt";
-            if (endValues.length > 0) endOperator = "primaryLte";
-            isBounded = true;
-          } else if ("primaryLte" in cond || "lte" in cond) {
-            const val = cond.primaryLte?.v ?? cond.lte?.v ?? cond.primaryLte ?? cond.lte;
-            score += 50;
-            isConsecutive = false;
-            endValues.push(val);
-            endOperator = "primaryLte";
-            if (startValues.length > 0) startOperator = "primaryGte";
-            isBounded = true;
-          } else if ("primaryLt" in cond || "lt" in cond) {
-            const val = cond.primaryLt?.v ?? cond.lt?.v ?? cond.primaryLt ?? cond.lt;
-            score += 50;
-            isConsecutive = false;
-            endValues.push(val);
-            endOperator = "primaryLt";
-            if (startValues.length > 0) startOperator = "primaryGte";
-            isBounded = true;
-          } else if ("primaryOr" in cond || "or" in cond) {
-            score += 20;
-            isConsecutive = false;
-          } else if ("like" in cond) {
-            score += 15;
-            isConsecutive = false;
-          } else {
-            score += 10;
-            isConsecutive = false;
+    }
+    if (ftsIndices.size === 0) return JSON.stringify({ _sampleSize: this.sampleSize });
+    for (let i = 0, len = docs.length; i < len; i++) {
+      const doc = docs[i];
+      const flatDoc = this.api.flattenDocument(doc);
+      for (const [indexName, config] of ftsIndices) {
+        const primaryField = this.api.indexManager.getPrimaryField(config);
+        const v = flatDoc[primaryField];
+        if (typeof v === "string" && v.length > 0) {
+          const ftsConfig = this.api.indexManager.getFtsConfig(config);
+          const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
+          const tokenizerStrategy = ftsConfig ? ftsConfig.tokenizer === "ngram" ? `${ftsConfig.gramSize}gram` : ftsConfig.tokenizer : "whitespace";
+          if (!this.termCount[primaryField]) {
+            this.termCount[primaryField] = {};
           }
-          if (!isBounded && field !== primaryField) {
-            compositeVerifyFields.push(field);
+          if (!this.termCount[primaryField][tokenizerStrategy]) {
+            this.termCount[primaryField][tokenizerStrategy] = {};
+          }
+          const targetMap = this.termCount[primaryField][tokenizerStrategy];
+          for (let j = 0, len2 = tokens.length; j < len2; j++) {
+            const token = tokens[j];
+            targetMap[token] = (targetMap[token] || 0) + 1;
           }
-        }
-      } else {
-        if (field !== primaryField) {
-          compositeVerifyFields.push(field);
         }
       }
     }
-    if (coveredFields.length === 1 && config.fields.length === 1) {
-      Object.assign(builtCondition, query[primaryField]);
-    } else {
-      if (startOperator && startValues.length > 0) {
-        builtCondition[startOperator] = { v: startValues.length === 1 ? startValues[0] : startValues };
-      }
-      if (endOperator && endValues.length > 0) {
-        if (startOperator && startValues.length === endValues.length && startValues.every((val, i) => val === endValues[i])) {
-          delete builtCondition[startOperator];
-          builtCondition["primaryEqual"] = { v: startValues.length === 1 ? startValues[0] : startValues };
-        } else {
-          builtCondition[endOperator] = { v: endValues.length === 1 ? endValues[0] : endValues };
+    const optimizedTermCount = {};
+    for (const field in this.termCount) {
+      optimizedTermCount[field] = {};
+      for (const strategy in this.termCount[field]) {
+        const tokenMap = this.termCount[field][strategy];
+        const sorted = Object.entries(tokenMap).sort((a, b) => b[1] - a[1]).slice(0, 1e3);
+        optimizedTermCount[field][strategy] = {};
+        for (let i = 0, len = sorted.length; i < len; i++) {
+          optimizedTermCount[field][strategy][sorted[i][0]] = sorted[i][1];
         }
       }
-      if (Object.keys(builtCondition).length === 0) {
-        Object.assign(builtCondition, query[primaryField] || {});
-      }
     }
-    let isIndexOrderSupported = false;
-    if (orderByField) {
-      for (let i = 0, len = config.fields.length; i < len; i++) {
-        const field = config.fields[i];
-        if (field === orderByField) {
-          isIndexOrderSupported = true;
-          break;
-        }
-        const cond = query[field];
-        let isExactMatch = false;
-        if (cond !== void 0) {
-          if (typeof cond !== "object" || cond === null) isExactMatch = true;
-          else if ("primaryEqual" in cond || "equal" in cond) isExactMatch = true;
-        }
-        if (!isExactMatch) break;
+    this.termCount = optimizedTermCount;
+    return JSON.stringify({ _sampleSize: this.sampleSize, ...this.termCount });
+  }
+  async load(data, tx) {
+    this.termCount = {};
+    this.sampleSize = 0;
+    if (!data) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        const { _sampleSize, ...rest } = parsed;
+        this.sampleSize = typeof _sampleSize === "number" ? _sampleSize : 0;
+        this.termCount = rest;
+      }
+    } catch (e) {
+    }
+  }
+  /**
+   * 특정 field/strategy/token의 문서 빈도를 반환합니다.
+   * 통계에 없으면 0을 반환합니다.
+   */
+  getTermCount(field, strategy, token) {
+    return this.termCount[field]?.[strategy]?.[token] ?? 0;
+  }
+  /**
+   * 쿼리 토큰 배열에서 최소 빈도(AND 시맨틱스 상한선)를 반환합니다.
+   * 통계가 없거나 sampleSize가 0이면 -1을 반환합니다.
+   */
+  getMinTokenCount(field, strategy, tokens) {
+    if (this.sampleSize === 0 || tokens.length === 0) return -1;
+    let minCount = Infinity;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const count = this.getTermCount(field, strategy, tokens[i]);
+      if (count < minCount) minCount = count;
+    }
+    return minCount === Infinity ? -1 : minCount;
+  }
+  /**
+   * 통계가 유효한지 여부를 반환합니다.
+   */
+  get hasSampleData() {
+    return this.sampleSize > 0;
+  }
+  /**
+   * 통계 수집 시 사용된 샘플 크기를 반환합니다.
+   */
+  getSampleSize() {
+    return this.sampleSize;
+  }
+};
+
+// src/core/analysis/index.ts
+var BuiltinAnalysisProviders = [
+  FTSTermCount
+];
+
+// src/core/AnalysisManager.ts
+var AnalysisManager = class {
+  constructor(api) {
+    this.api = api;
+  }
+  providers = /* @__PURE__ */ new Map();
+  /**
+   * Register all built-in analysis providers.
+   * Each provider class is instantiated with the API reference and registered.
+   */
+  registerBuiltinProviders() {
+    for (const Provider of BuiltinAnalysisProviders) {
+      const instance = new Provider(this.api);
+      this.registerProvider(instance);
+    }
+  }
+  /**
+   * Register an analysis provider.
+   * @param provider The provider instance to register
+   */
+  registerProvider(provider) {
+    if (this.providers.has(provider.name)) {
+      throw new Error(`Analysis provider "${provider.name}" is already registered.`);
+    }
+    this.providers.set(provider.name, provider);
+  }
+  /**
+   * Get a registered analysis provider by name.
+   * @param name The provider name
+   * @returns The provider instance, or null if not found
+   */
+  getProvider(name) {
+    return this.providers.get(name) ?? null;
+  }
+  /**
+   * Initialize all registered providers by loading existing data from disk.
+   * Should be called after database initialization.
+   * @param tx The transaction to use
+   */
+  async initializeProviders(tx) {
+    const header = await this.getOrCreateAnalysisHeader(tx);
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    for (const [name, provider] of this.providers) {
+      if (header[name] !== null) {
+        provider.storageKey = header[name];
+        const raw = await this.api.select(header[name], false, tx);
+        await provider.load(raw, tx);
+      } else {
+        const pk = await this.api.insertAsOverflow(JSON.stringify(null), false, tx);
+        provider.storageKey = pk;
+        header[name] = pk;
+        await this.api.update(metadata.analysis, JSON.stringify(header), tx);
+        await provider.load(null, tx);
       }
-      if (isIndexOrderSupported) {
-        score += 200;
+    }
+  }
+  /**
+   * Notify all realtime providers that documents were inserted.
+   * Data is persisted immediately after each provider processes the mutation.
+   * @param documents The flattened documents that were inserted
+   * @param tx The transaction to use
+   */
+  async notifyInsert(documents, tx) {
+    if (documents.length === 0) return;
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof RealtimeAnalysisProvider) {
+        await provider.onInsert(documents);
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
       }
     }
-    return {
-      tree: treeTx,
-      condition: builtCondition,
-      field: primaryField,
-      indexName,
-      isFtsMatch: false,
-      score,
-      compositeVerifyFields,
-      coveredFields,
-      isIndexOrderSupported
-    };
   }
   /**
-   * FTS (Full Text Search) 타입 인덱스의 선택도를 평가합니다.
-   * 'match' 연산자가 쿼리에 존재하는지 확인하고, 검색용 토큰으로 분해(tokenize)하여 점수를 매깁니다.
-   * 
-   * @param indexName 평가할 인덱스의 이름
-   * @param config 등록된 인덱스의 설정 객체
-   * @param query 쿼리 객체
-   * @param queryFields 쿼리에 포함된 필드 목록 집합
-   * @param treeTx 조회를 수행할 B-Tree 트랜잭션 객체
-   * @returns FTS 인덱스 후보 정보 (조건, 점수, 분석된 토큰 등), 적합하지 않으면 null
+   * Notify all realtime providers that documents were deleted.
+   * Data is persisted immediately after each provider processes the mutation.
+   * @param documents The flattened documents that were deleted
+   * @param tx The transaction to use
    */
-  evaluateFTSCandidate(indexName, config, query, queryFields, treeTx) {
-    const field = config.fields;
-    if (!queryFields.has(field)) return null;
-    const condition = query[field];
-    if (!condition || typeof condition !== "object" || !("match" in condition)) return null;
-    const ftsConfig = this.getFtsConfig(config);
-    const matchTokens = ftsConfig ? tokenize(condition.match, ftsConfig) : [];
-    return {
-      tree: treeTx,
-      condition,
-      field,
-      indexName,
-      isFtsMatch: true,
-      matchTokens,
-      score: 90,
-      // FTS 쿼리는 기본적인 B-Tree 단일 검색(대략 101점)보다는 우선순위를 조금 낮게 가져가도록 90점 부여
-      compositeVerifyFields: [],
-      coveredFields: [field],
-      isIndexOrderSupported: false
-    };
+  async notifyDelete(documents, tx) {
+    if (documents.length === 0) return;
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof RealtimeAnalysisProvider) {
+        await provider.onDelete(documents);
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
+      }
+    }
   }
   /**
-   * Choose the best index (driver) for the given query.
-   * Scores each index based on field coverage and condition type.
-   *
-   * @param query The verbose query conditions
-   * @param orderByField Optional field name for orderBy optimization
-   * @returns Driver and other candidates for query execution
+   * Notify all realtime providers that documents were updated.
+   * Data is persisted immediately after each provider processes the mutation.
+   * @param pairs Array of { oldDocument, newDocument } pairs
+   * @param tx The transaction to use
    */
-  async getSelectivityCandidate(query, orderByField) {
-    const queryFields = new Set(Object.keys(query));
-    const candidates = [];
-    for (const [indexName, config] of this.registeredIndices) {
-      const tree = this.trees.get(indexName);
-      if (!tree) continue;
-      if (config.type === "btree") {
-        const treeTx = await tree.createTransaction();
-        const candidate = this.evaluateBTreeCandidate(
-          indexName,
-          config,
-          query,
-          queryFields,
-          treeTx,
-          orderByField
-        );
-        if (candidate) candidates.push(candidate);
-      } else if (config.type === "fts") {
-        const treeTx = await tree.createTransaction();
-        const candidate = this.evaluateFTSCandidate(
-          indexName,
-          config,
-          query,
-          queryFields,
-          treeTx
-        );
-        if (candidate) candidates.push(candidate);
+  async notifyUpdate(pairs, tx) {
+    if (pairs.length === 0) return;
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof RealtimeAnalysisProvider) {
+        await provider.onUpdate(pairs);
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
       }
     }
-    const rollback = () => {
-      for (const { tree } of candidates) {
-        tree.rollback();
+  }
+  /**
+   * Flush all interval providers' data to disk.
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async flush(tx) {
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof IntervalAnalysisProvider) {
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
       }
-    };
-    if (candidates.length === 0) {
-      rollback();
+    }
+  }
+  /**
+   * Get the analysis header row.
+   * Returns null if no analysis header exists yet.
+   * @param tx The transaction to use
+   */
+  async getAnalysisHeader(tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (metadata.analysis == null) {
       return null;
     }
-    candidates.sort((a, b) => {
-      if (b.score !== a.score) return b.score - a.score;
-      const aConfig = this.registeredIndices.get(a.indexName);
-      const bConfig = this.registeredIndices.get(b.indexName);
-      const aFieldCount = aConfig ? Array.isArray(aConfig.fields) ? aConfig.fields.length : 1 : 0;
-      const bFieldCount = bConfig ? Array.isArray(bConfig.fields) ? bConfig.fields.length : 1 : 0;
-      return aFieldCount - bFieldCount;
-    });
-    const driver = candidates[0];
-    const driverCoveredFields = new Set(driver.coveredFields);
-    const others = candidates.slice(1).filter((c) => !driverCoveredFields.has(c.field));
-    const compositeVerifyConditions = [];
-    for (let i = 0, len = driver.compositeVerifyFields.length; i < len; i++) {
-      const field = driver.compositeVerifyFields[i];
-      if (query[field]) {
-        compositeVerifyConditions.push({ field, condition: query[field] });
+    const row = await this.api.select(metadata.analysis, false, tx);
+    if (!row) {
+      return null;
+    }
+    return JSON.parse(row);
+  }
+  /**
+   * Get the analysis header row, creating it if it doesn't exist.
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async getOrCreateAnalysisHeader(tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (metadata.analysis != null) {
+      const row = await this.api.select(metadata.analysis, false, tx);
+      if (row) {
+        return JSON.parse(row);
       }
     }
-    return {
-      driver,
-      others,
-      compositeVerifyConditions,
-      rollback
-    };
+    const header = {};
+    const pk = await this.api.insertAsOverflow(JSON.stringify(header), false, tx);
+    metadata.analysis = pk;
+    await this.api.updateDocumentInnerMetadata(metadata, tx);
+    return header;
   }
   /**
-   * Get Free Memory Chunk Size
-   * @returns { verySmallChunkSize, smallChunkSize }
+   * Get analysis data for a specific type as a raw string.
+   * Returns null if the type doesn't exist in the analysis header.
+   * @param type The analysis type name
+   * @param tx The transaction to use
    */
-  getFreeMemoryChunkSize() {
-    const freeMem = os.freemem();
-    const safeLimit = freeMem * 0.2;
-    const verySmallChunkSize = safeLimit * 0.05;
-    const smallChunkSize = safeLimit * 0.3;
-    return { verySmallChunkSize, smallChunkSize };
+  async getAnalysisData(type, tx) {
+    const header = await this.getAnalysisHeader(tx);
+    if (!header || header[type] == null) {
+      return null;
+    }
+    const row = await this.api.select(header[type], false, tx);
+    if (!row) {
+      return null;
+    }
+    return row;
   }
-  getTokenKey(pk, token) {
-    return pk + ":" + token;
+  /**
+   * Set analysis data for a specific type.
+   * Creates a new overflow row if the type doesn't exist yet,
+   * or updates the existing row if it does.
+   * @param type The analysis type name
+   * @param data The raw string data to store
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async setAnalysisData(type, data, tx) {
+    const header = await this.getOrCreateAnalysisHeader(tx);
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (header[type] != null) {
+      await this.api.update(header[type], data, tx);
+    } else {
+      const pk = await this.api.insertAsOverflow(data, false, tx);
+      header[type] = pk;
+      await this.api.update(metadata.analysis, JSON.stringify(header), tx);
+    }
   }
-  async *applyCandidateByFTSStream(candidate, matchedTokens, filterValues, order) {
-    const keys = /* @__PURE__ */ new Set();
-    for (let i = 0, len = matchedTokens.length; i < len; i++) {
-      const token = matchedTokens[i];
-      for await (const pair of candidate.tree.whereStream(
-        { primaryEqual: { v: token } },
-        { order }
-      )) {
-        const pk = pair[1].k;
-        if (filterValues && !filterValues.has(pk)) continue;
-        if (!keys.has(pk)) {
-          keys.add(pk);
-          yield pk;
-        }
-      }
+  /**
+   * Delete analysis data for a specific type.
+   * Removes the type entry from the analysis header.
+   * @param type The analysis type name
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async deleteAnalysisData(type, tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (metadata.analysis == null) {
+      return false;
+    }
+    const header = await this.getAnalysisHeader(tx);
+    if (!header || header[type] == null) {
+      return false;
     }
+    await this.api.delete(header[type], false, tx);
+    delete header[type];
+    await this.api.update(metadata.analysis, JSON.stringify(header), tx);
+    return true;
   }
   /**
-   * 특정 인덱스 후보를 조회하여 PK 집합을 필터링합니다.
+   * Check if analysis data exists for a specific type.
+   * @param type The analysis type name
+   * @param tx The transaction to use
    */
-  applyCandidateStream(candidate, filterValues, order) {
-    return candidate.tree.keysStream(
-      candidate.condition,
-      { filterValues, order }
-    );
+  async hasAnalysisData(type, tx) {
+    const header = await this.getAnalysisHeader(tx);
+    return header != null && header[type] != null;
   }
   /**
-   * 쿼리와 인덱스 선택을 기반으로 기본 키(Primary Keys)를 가져옵니다.
-   * 쿼리 최적화를 통합하기 위한 내부 공통 메서드입니다.
+   * Get all registered analysis type names.
+   * @param tx The transaction to use
    */
-  async getKeys(query, orderBy, sortOrder = "asc") {
-    const isQueryEmpty = Object.keys(query).length === 0;
-    const normalizedQuery = isQueryEmpty ? { _id: { gte: 0 } } : query;
-    const selectivity = await this.getSelectivityCandidate(
-      this.verboseQuery(normalizedQuery),
-      orderBy
-    );
-    if (!selectivity) return new Float64Array(0);
-    const { driver, others, rollback } = selectivity;
-    const useIndexOrder = orderBy === void 0 || driver.isIndexOrderSupported;
-    const candidates = [driver, ...others];
-    let keys = void 0;
-    for (let i = 0, len = candidates.length; i < len; i++) {
-      const candidate = candidates[i];
-      const currentOrder = useIndexOrder ? sortOrder : void 0;
-      if (candidate.isFtsMatch && candidate.matchTokens && candidate.matchTokens.length > 0) {
-        const stream = this.applyCandidateByFTSStream(
-          candidate,
-          candidate.matchTokens,
-          keys,
-          currentOrder
-        );
-        keys = /* @__PURE__ */ new Set();
-        for await (const pk of stream) keys.add(pk);
-      } else {
-        const stream = this.applyCandidateStream(candidate, keys, currentOrder);
-        keys = /* @__PURE__ */ new Set();
-        for await (const pk of stream) keys.add(pk);
-      }
+  async getAnalysisTypes(tx) {
+    const header = await this.getAnalysisHeader(tx);
+    if (!header) {
+      return [];
     }
-    rollback();
-    return new Float64Array(Array.from(keys || []));
+    return Object.keys(header);
+  }
+};
+
+// src/core/documentAPI.ts
+var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
+  comparator = new DocumentValueComparator();
+  _initialized = false;
+  optimizer;
+  queryManager;
+  indexManager;
+  mutationManager;
+  metadataManager;
+  documentFormatter;
+  analysisManager;
+  constructor(file, options) {
+    super(file, options);
+    this.optimizer = new Optimizer(this);
+    this.queryManager = new QueryManager(this, this.optimizer);
+    this.indexManager = new IndexManager(this);
+    this.mutationManager = new MutationManager(this);
+    this.metadataManager = new MetadataManager(this);
+    this.documentFormatter = new DocumentFormatter();
+    this.analysisManager = new AnalysisManager(this);
+    this.hook.onceAfter("init", async (tx, isNewlyCreated) => {
+      if (isNewlyCreated) {
+        await this.initializeDocumentFile(tx);
+      }
+      if (!await this.verifyDocumentFile(tx)) {
+        throw new Error("Document metadata verification failed");
+      }
+      const metadata = await this.getDocumentInnerMetadata(tx);
+      await this.indexManager.initializeIndices(metadata, isNewlyCreated, tx);
+      this.analysisManager.registerBuiltinProviders();
+      await this.analysisManager.initializeProviders(tx);
+      this._initialized = true;
+      return tx;
+    });
   }
   /**
-   * 드라이버 인덱스만으로 PK 스트림을 가져옵니다. (교집합 없이)
-   * selectDocuments에서 사용하며, 나머지 조건(others)은 스트리밍 중 tree.verify()로 검증합니다.
-   * @returns 드라이버 키 스트림, others 후보 목록, rollback 함수. 또는 null.
+   * Whether the document database has been initialized.
    */
-  async getDriverKeys(query, orderBy, sortOrder = "asc") {
-    const isQueryEmpty = Object.keys(query).length === 0;
-    const normalizedQuery = isQueryEmpty ? { _id: { gte: 0 } } : query;
-    const selectivity = await this.getSelectivityCandidate(
-      this.verboseQuery(normalizedQuery),
-      orderBy
-    );
-    if (!selectivity) return null;
-    const { driver, others, compositeVerifyConditions, rollback } = selectivity;
-    const useIndexOrder = orderBy === void 0 || driver.isIndexOrderSupported;
-    const currentOrder = useIndexOrder ? sortOrder : void 0;
-    let keysStream;
-    if (driver.isFtsMatch && driver.matchTokens && driver.matchTokens.length > 0) {
-      keysStream = this.applyCandidateByFTSStream(
-        driver,
-        driver.matchTokens,
-        void 0,
-        currentOrder
-      );
-    } else {
-      keysStream = this.applyCandidateStream(driver, void 0, currentOrder);
-    }
-    return {
-      keysStream,
-      others,
-      compositeVerifyConditions,
-      isDriverOrderByField: useIndexOrder,
-      rollback
-    };
+  get isDocInitialized() {
+    return this._initialized;
   }
-  async insertDocumentInternal(document, tx) {
-    const metadata = await this.getDocumentInnerMetadata(tx);
-    const id = ++metadata.lastId;
-    await this.updateDocumentInnerMetadata(metadata, tx);
-    const dataplyDocument = Object.assign({
-      _id: id
-    }, document);
-    const pk = await super.insert(JSON.stringify(dataplyDocument), true, tx);
-    return {
-      pk,
-      id,
-      document: dataplyDocument
-    };
+  get indices() {
+    return this.indexManager.indices;
+  }
+  get trees() {
+    return this.indexManager.trees;
+  }
+  get indexedFields() {
+    return this.indexManager.indexedFields;
+  }
+  /**
+   * Register an index.
+   * @param name The name of the index
+   * @param option The option of the index
+   * @param tx The transaction to use
+   */
+  async registerIndex(name, option, tx) {
+    return this.indexManager.registerIndex(name, option, tx);
+  }
+  /**
+   * Drop (remove) a named index.
+   * @param name The name of the index
+   * @param tx The transaction to use
+   */
+  async dropIndex(name, tx) {
+    return this.indexManager.dropIndex(name, tx);
   }
   /**
-   * Insert a document into the database
-   * @param document The document to insert
+   * Get a document by its primary key.
+   * @param pk The primary key of the document
    * @param tx The transaction to use
-   * @returns The primary key of the inserted document
+   * @returns The document
    */
-  async insertSingleDocument(document, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      const { pk: dpk, document: dataplyDocument } = await this.insertDocumentInternal(document, tx2);
-      const flattenDocument = this.flattenDocument(dataplyDocument);
-      for (const [indexName, config] of this.registeredIndices) {
-        const tree = this.trees.get(indexName);
-        if (!tree) continue;
-        if (config.type === "fts") {
-          const primaryField = this.getPrimaryField(config);
-          const v = flattenDocument[primaryField];
-          if (v === void 0 || typeof v !== "string") continue;
-          const ftsConfig = this.getFtsConfig(config);
-          const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
-          for (let i = 0, len = tokens.length; i < len; i++) {
-            const token = tokens[i];
-            const keyToInsert = this.getTokenKey(dpk, token);
-            const [error] = await catchPromise(tree.insert(keyToInsert, { k: dpk, v: token }));
-            if (error) throw error;
-          }
-        } else {
-          const indexVal = this.getIndexValue(config, flattenDocument);
-          if (indexVal === void 0) continue;
-          const [error] = await catchPromise(tree.insert(dpk, { k: dpk, v: indexVal }));
-          if (error) throw error;
-        }
+  async getDocument(pk, tx) {
+    return this.runWithDefault(async (tx2) => {
+      const row = await this.select(pk, false, tx2);
+      if (!row) {
+        throw new Error(`Document not found with PK: ${pk}`);
       }
-      return dataplyDocument._id;
+      return JSON.parse(row);
     }, tx);
   }
   /**
-   * Insert a batch of documents into the database
-   * @param documents The documents to insert
+   * Backfill indices for newly created indices after data was inserted.
+   * Delegated to IndexManager.
+   */
+  async backfillIndices(tx) {
+    return this.indexManager.backfillIndices(tx);
+  }
+  /**
+   * Flush all interval analysis providers, forcing statistics to be recalculated.
+   * Call this after bulk inserts or periodically to keep statistics fresh.
    * @param tx The transaction to use
-   * @returns The primary keys of the inserted documents
    */
-  async insertBatchDocuments(documents, tx) {
+  async flushAnalysis(tx) {
     return this.runWithDefaultWrite(async (tx2) => {
-      const metadata = await this.getDocumentInnerMetadata(tx2);
-      const startId = metadata.lastId + 1;
-      metadata.lastId += documents.length;
-      await this.updateDocumentInnerMetadata(metadata, tx2);
-      const ids = [];
-      const dataplyDocuments = [];
-      const flattenedData = [];
-      for (let i = 0, len = documents.length; i < len; i++) {
-        const id = startId + i;
-        const dataplyDocument = Object.assign({
-          _id: id
-        }, documents[i]);
-        const stringified = JSON.stringify(dataplyDocument);
-        dataplyDocuments.push(stringified);
-        const flattenDocument = this.flattenDocument(dataplyDocument);
-        flattenedData.push({ pk: -1, data: flattenDocument });
-        ids.push(id);
-      }
-      const pks = await super.insertBatch(dataplyDocuments, true, tx2);
-      for (let i = 0, len = pks.length; i < len; i++) {
-        flattenedData[i].pk = pks[i];
-      }
-      for (const [indexName, config] of this.registeredIndices) {
-        const tree = this.trees.get(indexName);
-        if (!tree) continue;
-        const treeTx = await tree.createTransaction();
-        const batchInsertData = [];
-        if (config.type === "fts") {
-          const primaryField = this.getPrimaryField(config);
-          const ftsConfig = this.getFtsConfig(config);
-          for (let i = 0, len = flattenedData.length; i < len; i++) {
-            const item = flattenedData[i];
-            const v = item.data[primaryField];
-            if (v === void 0 || typeof v !== "string") continue;
-            const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
-            for (let j = 0, tLen = tokens.length; j < tLen; j++) {
-              const token = tokens[j];
-              batchInsertData.push([this.getTokenKey(item.pk, token), { k: item.pk, v: token }]);
-            }
-          }
-        } else {
-          for (let i = 0, len = flattenedData.length; i < len; i++) {
-            const item = flattenedData[i];
-            const indexVal = this.getIndexValue(config, item.data);
-            if (indexVal === void 0) continue;
-            batchInsertData.push([item.pk, { k: item.pk, v: indexVal }]);
-          }
-        }
-        const [error] = await catchPromise(treeTx.batchInsert(batchInsertData));
-        if (error) {
-          throw error;
-        }
-        const res = await treeTx.commit();
-        if (!res.success) {
-          throw res.error;
-        }
-      }
-      return ids;
+      await this.analysisManager.flush(tx2);
     }, tx);
   }
+  createDocumentInnerMetadata(indices) {
+    return {
+      magicString: "document-dataply",
+      version: 1,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      lastId: 0,
+      schemeVersion: 0,
+      indices
+    };
+  }
   /**
-   * Internal update method used by both fullUpdate and partialUpdate
-   * @param query The query to use
-   * @param computeUpdatedDoc Function that computes the updated document from the original
+   * Initialize the document database file.
    * @param tx The transaction to use
-   * @returns The number of updated documents
    */
-  async updateInternal(query, computeUpdatedDoc, tx) {
-    const pks = await this.getKeys(query);
-    let updatedCount = 0;
-    const treeTxs = /* @__PURE__ */ new Map();
-    for (const [indexName, tree] of this.trees) {
-      treeTxs.set(indexName, await tree.createTransaction());
-    }
-    treeTxs.delete("_id");
-    for (let i = 0, len = pks.length; i < len; i++) {
-      const pk = pks[i];
-      const doc = await this.getDocument(pk, tx);
-      if (!doc) continue;
-      const updatedDoc = computeUpdatedDoc(doc);
-      const oldFlatDoc = this.flattenDocument(doc);
-      const newFlatDoc = this.flattenDocument(updatedDoc);
-      for (const [indexName, treeTx] of treeTxs) {
-        const config = this.registeredIndices.get(indexName);
-        if (!config) continue;
-        if (config.type === "fts") {
-          const primaryField = this.getPrimaryField(config);
-          const oldV = oldFlatDoc[primaryField];
-          const newV = newFlatDoc[primaryField];
-          if (oldV === newV) continue;
-          const ftsConfig = this.getFtsConfig(config);
-          if (typeof oldV === "string") {
-            const oldTokens = ftsConfig ? tokenize(oldV, ftsConfig) : [oldV];
-            for (let j = 0, jLen = oldTokens.length; j < jLen; j++) {
-              await treeTx.delete(this.getTokenKey(pk, oldTokens[j]), { k: pk, v: oldTokens[j] });
-            }
-          }
-          if (typeof newV === "string") {
-            const newTokens = ftsConfig ? tokenize(newV, ftsConfig) : [newV];
-            const batchInsertData = [];
-            for (let j = 0, jLen = newTokens.length; j < jLen; j++) {
-              batchInsertData.push([this.getTokenKey(pk, newTokens[j]), { k: pk, v: newTokens[j] }]);
-            }
-            await treeTx.batchInsert(batchInsertData);
-          }
-        } else {
-          const oldIndexVal = this.getIndexValue(config, oldFlatDoc);
-          const newIndexVal = this.getIndexValue(config, newFlatDoc);
-          if (JSON.stringify(oldIndexVal) === JSON.stringify(newIndexVal)) continue;
-          if (oldIndexVal !== void 0) {
-            await treeTx.delete(pk, { k: pk, v: oldIndexVal });
-          }
-          if (newIndexVal !== void 0) {
-            await treeTx.batchInsert([[pk, { k: pk, v: newIndexVal }]]);
-          }
-        }
-      }
-      await this.update(pk, JSON.stringify(updatedDoc), tx);
-      updatedCount++;
+  async initializeDocumentFile(tx) {
+    const metadata = await this.select(1, false, tx);
+    if (metadata) {
+      throw new Error("Document metadata already exists");
     }
-    for (const [indexName, treeTx] of treeTxs) {
-      const result = await treeTx.commit();
-      if (!result.success) {
-        for (const rollbackTx of treeTxs.values()) {
-          rollbackTx.rollback();
-        }
-        throw result.error;
-      }
+    const metaObj = this.createDocumentInnerMetadata({
+      _id: [-1, {
+        type: "btree",
+        fields: ["_id"]
+      }]
+    });
+    await this.insertAsOverflow(JSON.stringify(metaObj), false, tx);
+  }
+  /**
+   * Verify the document database file.
+   * @param tx The transaction to use
+   * @returns True if the document database file is valid, false otherwise
+   */
+  async verifyDocumentFile(tx) {
+    const row = await this.select(1, false, tx);
+    if (!row) {
+      return false;
     }
-    return updatedCount;
+    const data = JSON.parse(row);
+    return data.magicString === "document-dataply" && data.version === 1;
   }
   /**
-   * Fully update documents from the database that match the query
-   * @param query The query to use
-   * @param newRecord Complete document to replace with, or function that receives current document and returns new document
+   * returns flattened document
+   * @param document
+   * @returns
+   */
+  flattenDocument(document) {
+    return this.documentFormatter.flattenDocument(document);
+  }
+  /**
+   * Get the document metadata.
    * @param tx The transaction to use
-   * @returns The number of updated documents
+   * @returns The document metadata
    */
-  async fullUpdate(query, newRecord, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      return this.updateInternal(query, (doc) => {
-        const newDoc = typeof newRecord === "function" ? newRecord(doc) : newRecord;
-        return { _id: doc._id, ...newDoc };
-      }, tx2);
-    }, tx);
+  async getDocumentMetadata(tx) {
+    return this.metadataManager.getDocumentMetadata(tx);
   }
   /**
-   * Partially update documents from the database that match the query
-   * @param query The query to use
-   * @param newRecord Partial document to merge, or function that receives current document and returns partial update
+   * Get the document inner metadata.
    * @param tx The transaction to use
-   * @returns The number of updated documents
+   * @returns The document inner metadata
    */
-  async partialUpdate(query, newRecord, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      return this.updateInternal(query, (doc) => {
-        const partialUpdateContent = typeof newRecord === "function" ? newRecord(doc) : newRecord;
-        const finalUpdate = { ...partialUpdateContent };
-        delete finalUpdate._id;
-        return { ...doc, ...finalUpdate };
-      }, tx2);
-    }, tx);
+  async getDocumentInnerMetadata(tx) {
+    return this.metadataManager.getDocumentInnerMetadata(tx);
   }
   /**
-   * Delete documents from the database that match the query
-   * @param query The query to use
+   * Update the document inner metadata.
+   * @param metadata The document inner metadata
    * @param tx The transaction to use
-   * @returns The number of deleted documents
    */
-  async deleteDocuments(query, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      const pks = await this.getKeys(query);
-      let deletedCount = 0;
-      for (let i = 0, len = pks.length; i < len; i++) {
-        const pk = pks[i];
-        const doc = await this.getDocument(pk, tx2);
-        if (!doc) continue;
-        const flatDoc = this.flattenDocument(doc);
-        for (const [indexName, tree] of this.trees) {
-          const config = this.registeredIndices.get(indexName);
-          if (!config) continue;
-          if (config.type === "fts") {
-            const primaryField = this.getPrimaryField(config);
-            const v = flatDoc[primaryField];
-            if (v === void 0 || typeof v !== "string") continue;
-            const ftsConfig = this.getFtsConfig(config);
-            const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
-            for (let j = 0, jLen = tokens.length; j < jLen; j++) {
-              await tree.delete(this.getTokenKey(pk, tokens[j]), { k: pk, v: tokens[j] });
-            }
-          } else {
-            const indexVal = this.getIndexValue(config, flatDoc);
-            if (indexVal === void 0) continue;
-            await tree.delete(pk, { k: pk, v: indexVal });
-          }
-        }
-        await super.delete(pk, true, tx2);
-        deletedCount++;
-      }
-      return deletedCount;
-    }, tx);
+  async updateDocumentInnerMetadata(metadata, tx) {
+    return this.metadataManager.updateDocumentInnerMetadata(metadata, tx);
   }
   /**
-   * Count documents from the database that match the query
-   * @param query The query to use
+   * Run a migration if the current schemeVersion is lower than the target version.
+   * After the callback completes, schemeVersion is updated to the target version.
+   * @param version The target scheme version
+   * @param callback The migration callback
+   * @param tx Optional transaction
+   */
+  async migration(version, callback, tx) {
+    return this.metadataManager.migration(version, callback, tx);
+  }
+  /**
+   * Insert a document into the database
+   * @param document The document to insert
    * @param tx The transaction to use
-   * @returns The number of documents that match the query
+   * @returns The primary key of the inserted document
    */
-  async countDocuments(query, tx) {
-    return this.runWithDefault(async (tx2) => {
-      const pks = await this.getKeys(query);
-      return pks.length;
-    }, tx);
+  async insertSingleDocument(document, tx) {
+    return this.mutationManager.insertSingleDocument(document, tx);
   }
   /**
-   * FTS 조건에 대해 문서가 유효한지 검증합니다.
+   * Insert a batch of documents into the database
+   * @param documents The documents to insert
+   * @param tx The transaction to use
+   * @returns The primary keys of the inserted documents
    */
-  verifyFts(doc, ftsConditions) {
-    const flatDoc = this.flattenDocument(doc);
-    for (let i = 0, len = ftsConditions.length; i < len; i++) {
-      const { field, matchTokens } = ftsConditions[i];
-      const docValue = flatDoc[field];
-      if (typeof docValue !== "string") return false;
-      for (let j = 0, jLen = matchTokens.length; j < jLen; j++) {
-        const token = matchTokens[j];
-        if (!docValue.includes(token)) return false;
-      }
-    }
-    return true;
+  async insertBatchDocuments(documents, tx) {
+    return this.mutationManager.insertBatchDocuments(documents, tx);
   }
   /**
-   * 복합 인덱스의 non-primary 필드에 대해 문서가 유효한지 검증합니다.
+   * Fully update documents from the database that match the query
+   * @param query The query to use
+   * @param newRecord Complete document to replace with, or function that receives current document and returns new document
+   * @param tx The transaction to use
+   * @returns The number of updated documents
    */
-  verifyCompositeConditions(doc, conditions) {
-    if (conditions.length === 0) return true;
-    const flatDoc = this.flattenDocument(doc);
-    for (let i = 0, len = conditions.length; i < len; i++) {
-      const { field, condition } = conditions[i];
-      const docValue = flatDoc[field];
-      if (docValue === void 0) return false;
-      const treeValue = { k: doc._id, v: docValue };
-      if (!this.verifyValue(docValue, condition)) return false;
-    }
-    return true;
+  async fullUpdate(query, newRecord, tx) {
+    return this.mutationManager.fullUpdate(query, newRecord, tx);
   }
   /**
-   * 단일 값에 대해 verbose 조건을 검증합니다.
+   * Partially update documents from the database that match the query
+   * @param query The query to use
+   * @param newRecord Partial document to merge, or function that receives current document and returns partial update
+   * @param tx The transaction to use
+   * @returns The number of updated documents
    */
-  verifyValue(value, condition) {
-    if (typeof condition !== "object" || condition === null) {
-      return value === condition;
-    }
-    if ("primaryEqual" in condition) {
-      return value === condition.primaryEqual?.v;
-    }
-    if ("primaryNotEqual" in condition) {
-      return value !== condition.primaryNotEqual?.v;
-    }
-    if ("primaryLt" in condition) {
-      return value !== null && condition.primaryLt?.v !== void 0 && value < condition.primaryLt.v;
-    }
-    if ("primaryLte" in condition) {
-      return value !== null && condition.primaryLte?.v !== void 0 && value <= condition.primaryLte.v;
-    }
-    if ("primaryGt" in condition) {
-      return value !== null && condition.primaryGt?.v !== void 0 && value > condition.primaryGt.v;
-    }
-    if ("primaryGte" in condition) {
-      return value !== null && condition.primaryGte?.v !== void 0 && value >= condition.primaryGte.v;
-    }
-    if ("primaryOr" in condition && Array.isArray(condition.primaryOr)) {
-      return condition.primaryOr.some((c) => value === c?.v);
-    }
-    return true;
+  async partialUpdate(query, newRecord, tx) {
+    return this.mutationManager.partialUpdate(query, newRecord, tx);
   }
   /**
-   * 메모리 기반으로 청크 크기를 동적 조절합니다.
+   * Delete documents from the database that match the query
+   * @param query The query to use
+   * @param tx The transaction to use
+   * @returns The number of deleted documents
    */
-  adjustChunkSize(currentChunkSize, chunkTotalSize) {
-    if (chunkTotalSize <= 0) return currentChunkSize;
-    const { verySmallChunkSize, smallChunkSize } = this.getFreeMemoryChunkSize();
-    if (chunkTotalSize < verySmallChunkSize) return currentChunkSize * 2;
-    if (chunkTotalSize > smallChunkSize) return Math.max(Math.floor(currentChunkSize / 2), 20);
-    return currentChunkSize;
+  async deleteDocuments(query, tx) {
+    return this.mutationManager.deleteDocuments(query, tx);
   }
   /**
-   * Prefetch 방식으로 키 스트림을 청크 단위로 조회하여 문서를 순회합니다.
-   * FTS 검증, 복합 인덱스 검증, others 후보에 대한 tree.verify() 검증을 통과한 문서만 yield 합니다.
+   * Count documents from the database that match the query
+   * @param query The query to use
+   * @param tx The transaction to use
+   * @returns The number of documents that match the query
    */
-  async *processChunkedKeysWithVerify(keysStream, startIdx, initialChunkSize, limit, ftsConditions, compositeVerifyConditions, others, tx) {
-    const verifyOthers = others.filter((o) => !o.isFtsMatch);
-    const isFts = ftsConditions.length > 0;
-    const isCompositeVerify = compositeVerifyConditions.length > 0;
-    const isVerifyOthers = verifyOthers.length > 0;
-    const isFiniteLimit = isFinite(limit);
-    let currentChunkSize = isFiniteLimit ? limit : initialChunkSize;
-    let chunk = [];
-    let chunkSize = 0;
-    let dropped = 0;
-    const processChunk = async (pks) => {
-      const docs = [];
-      const rawResults = await this.selectMany(new Float64Array(pks), false, tx);
-      let chunkTotalSize = 0;
-      for (let j = 0, len = rawResults.length; j < len; j++) {
-        const s = rawResults[j];
-        if (!s) continue;
-        const doc = JSON.parse(s);
-        chunkTotalSize += s.length * 2;
-        if (isFts && !this.verifyFts(doc, ftsConditions)) continue;
-        if (isCompositeVerify && this.verifyCompositeConditions(doc, compositeVerifyConditions) === false) continue;
-        if (isVerifyOthers) {
-          const flatDoc = this.flattenDocument(doc);
-          let passed = true;
-          for (let k = 0, kLen = verifyOthers.length; k < kLen; k++) {
-            const other = verifyOthers[k];
-            const fieldValue = flatDoc[other.field];
-            if (fieldValue === void 0) {
-              passed = false;
-              break;
-            }
-            const treeValue = { k: doc._id, v: fieldValue };
-            if (!other.tree.verify(treeValue, other.condition)) {
-              passed = false;
-              break;
-            }
-          }
-          if (!passed) continue;
-        }
-        docs.push(doc);
-      }
-      if (!isFiniteLimit) {
-        currentChunkSize = this.adjustChunkSize(currentChunkSize, chunkTotalSize);
-      }
-      return docs;
-    };
-    for await (const pk of keysStream) {
-      if (dropped < startIdx) {
-        dropped++;
-        continue;
-      }
-      chunk.push(pk);
-      chunkSize++;
-      if (chunkSize >= currentChunkSize) {
-        const docs = await processChunk(chunk);
-        for (let j = 0, dLen = docs.length; j < dLen; j++) yield docs[j];
-        chunk = [];
-        chunkSize = 0;
-      }
-    }
-    if (chunkSize > 0) {
-      const docs = await processChunk(chunk);
-      for (let j = 0, dLen = docs.length; j < dLen; j++) yield docs[j];
-    }
+  async countDocuments(query, tx) {
+    return this.queryManager.countDocuments(query, tx);
   }
   /**
    * Select documents from the database
@@ -11954,130 +12630,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @throws Error if query or orderBy contains non-indexed fields
    */
   selectDocuments(query, options = {}, tx) {
-    for (const field of Object.keys(query)) {
-      if (!this.indexedFields.has(field)) {
-        throw new Error(`Query field "${field}" is not indexed. Available indexed fields: ${Array.from(this.indexedFields).join(", ")}`);
-      }
-    }
-    const orderBy = options.orderBy;
-    if (orderBy !== void 0 && !this.indexedFields.has(orderBy)) {
-      throw new Error(`orderBy field "${orderBy}" is not indexed. Available indexed fields: ${Array.from(this.indexedFields).join(", ")}`);
-    }
-    const {
-      limit = Infinity,
-      offset = 0,
-      sortOrder = "asc",
-      orderBy: orderByField
-    } = options;
-    const self = this;
-    const stream = () => this.streamWithDefault(async function* (tx2) {
-      const ftsConditions = [];
-      for (const field in query) {
-        const q = query[field];
-        if (q && typeof q === "object" && "match" in q && typeof q.match === "string") {
-          const indexNames = self.fieldToIndices.get(field) || [];
-          for (const indexName of indexNames) {
-            const config = self.registeredIndices.get(indexName);
-            if (config && config.type === "fts") {
-              const ftsConfig = self.getFtsConfig(config);
-              if (ftsConfig) {
-                ftsConditions.push({ field, matchTokens: tokenize(q.match, ftsConfig) });
-              }
-              break;
-            }
-          }
-        }
-      }
-      const driverResult = await self.getDriverKeys(query, orderByField, sortOrder);
-      if (!driverResult) return;
-      const { keysStream, others, compositeVerifyConditions, isDriverOrderByField, rollback } = driverResult;
-      const initialChunkSize = self.options.pageSize;
-      try {
-        if (!isDriverOrderByField && orderByField) {
-          const topK = limit === Infinity ? Infinity : offset + limit;
-          let heap = null;
-          if (topK !== Infinity) {
-            heap = new BinaryHeap((a, b) => {
-              const aVal = a[orderByField] ?? a._id;
-              const bVal = b[orderByField] ?? b._id;
-              const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-              return sortOrder === "asc" ? -cmp : cmp;
-            });
-          }
-          const results = [];
-          for await (const doc of self.processChunkedKeysWithVerify(
-            keysStream,
-            0,
-            initialChunkSize,
-            Infinity,
-            ftsConditions,
-            compositeVerifyConditions,
-            others,
-            tx2
-          )) {
-            if (heap) {
-              if (heap.size < topK) heap.push(doc);
-              else {
-                const top = heap.peek();
-                if (top) {
-                  const aVal = doc[orderByField] ?? doc._id;
-                  const bVal = top[orderByField] ?? top._id;
-                  const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-                  if (sortOrder === "asc" ? cmp < 0 : cmp > 0) heap.replace(doc);
-                }
-              }
-            } else {
-              results.push(doc);
-            }
-          }
-          const finalDocs = heap ? heap.toArray() : results;
-          finalDocs.sort((a, b) => {
-            const aVal = a[orderByField] ?? a._id;
-            const bVal = b[orderByField] ?? b._id;
-            const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-            return sortOrder === "asc" ? cmp : -cmp;
-          });
-          const end = limit === Infinity ? void 0 : offset + limit;
-          const limitedResults = finalDocs.slice(offset, end);
-          for (let j = 0, len = limitedResults.length; j < len; j++) {
-            yield limitedResults[j];
-          }
-        } else {
-          const hasFilters = ftsConditions.length > 0 || compositeVerifyConditions.length > 0 || others.length > 0;
-          const startIdx = hasFilters ? 0 : offset;
-          let yieldedCount = 0;
-          let skippedCount = hasFilters ? 0 : offset;
-          for await (const doc of self.processChunkedKeysWithVerify(
-            keysStream,
-            startIdx,
-            initialChunkSize,
-            limit,
-            ftsConditions,
-            compositeVerifyConditions,
-            others,
-            tx2
-          )) {
-            if (skippedCount < offset) {
-              skippedCount++;
-              continue;
-            }
-            if (yieldedCount >= limit) break;
-            yield doc;
-            yieldedCount++;
-          }
-        }
-      } finally {
-        rollback();
-      }
-    }, tx);
-    const drain = async () => {
-      const result = [];
-      for await (const document of stream()) {
-        result.push(document);
-      }
-      return result;
-    };
-    return { stream, drain };
+    return this.queryManager.selectDocuments(query, options, tx);
   }
 };
 
@@ -12150,6 +12703,14 @@ var DocumentDataply = class _DocumentDataply {
     await this.api.init();
     await this.api.backfillIndices();
   }
+  /**
+   * Flush all interval analysis providers, forcing statistics to be recalculated.
+   * Call this after bulk inserts or periodically to keep FTS statistics fresh.
+   * @param tx Optional transaction
+   */
+  async flushAnalysis(tx) {
+    return this.api.flushAnalysis(tx);
+  }
   /**
    * Run a migration if the current schemeVersion is lower than the target version.
    * The callback is only executed when the database's schemeVersion is below the given version.
@@ -12249,7 +12810,7 @@ var DocumentDataply = class _DocumentDataply {
 };
 
 // src/core/index.ts
-var import_dataply4 = __toESM(require_cjs());
+var import_dataply5 = __toESM(require_cjs());
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DocumentDataply,