document-dataply 0.0.10-alpha.2 → 0.0.10-alpha.4

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,343 +10465,992 @@ 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(
-        new DocumentSerializeStrategyAsync(
-          this.rowTableEngine.order,
-          this,
-          this.txContext,
-          name
-        ),
-        this.comparator
+      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 타입 인덱스의 선택도를 평가합니다.
+   */
+  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) : [];
+    return {
+      tree: treeTx,
+      condition,
+      field,
+      indexName,
+      isFtsMatch: true,
+      matchTokens,
+      score: 90,
+      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 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] });
+      }
+    }
+    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
       );
-      await tree.init();
-      this.trees.set(name, tree);
-      if (metadata.lastId > 0) {
-        this.pendingBackfillFields = [name];
-        await this.backfillIndices(tx2);
+    } 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;
       }
-    }, tx);
+    }
+    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 || !isCompositeVerify || !isVerifyOthers || !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 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];
+    }
   }
   /**
-   * 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
+   * 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 dropIndex(name, tx) {
-    if (name === "_id") {
-      throw new Error('Cannot drop the "_id" index.');
-    }
-    if (!this._initialized) {
-      this.pendingCreateIndices.delete(name);
-      return;
+  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(", ")}`);
+      }
     }
-    if (!this.registeredIndices.has(name)) {
-      throw new Error(`Index "${name}" does not exist.`);
+    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(", ")}`);
     }
-    await this.runWithDefaultWrite(async (tx2) => {
-      const config = this.registeredIndices.get(name);
-      const metadata = await this.getDocumentInnerMetadata(tx2);
-      delete metadata.indices[name];
-      await this.updateDocumentInnerMetadata(metadata, tx2);
-      this.indices = metadata.indices;
-      this.registeredIndices.delete(name);
-      const fields = this.getFieldsFromConfig(config);
-      for (let i = 0; i < fields.length; i++) {
-        const field = fields[i];
-        const indexNames = this.fieldToIndices.get(field);
-        if (indexNames) {
-          const filtered = indexNames.filter((n) => n !== name);
-          if (filtered.length === 0) {
-            this.fieldToIndices.delete(field);
-            if (field !== "_id") {
-              this.indexedFields.delete(field);
+    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;
             }
-          } else {
-            this.fieldToIndices.set(field, filtered);
+            if (yieldedCount >= limit) break;
+            yield doc;
+            yieldedCount++;
           }
         }
+      } finally {
+        rollback();
       }
-      this.trees.delete(name);
     }, 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;
   }
   /**
-   * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
+   * readHead에서 할당된 headPk를 캐싱하여
+   * writeHead에서 AsyncLocalStorage 컨텍스트 유실 시에도 사용할 수 있도록 함
    */
-  toIndexMetaConfig(option) {
-    if (!option || typeof option !== "object") {
-      throw new Error("Index option must be a non-null object");
+  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}`);
     }
-    if (!option.type) {
-      throw new Error('Index option must have a "type" property ("btree" or "fts")');
+    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;
     }
-    if (option.type === "btree") {
-      if (!Array.isArray(option.fields) || option.fields.length === 0) {
-        throw new Error('btree index requires a non-empty "fields" array');
+    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.`);
       }
-      for (let i = 0, len = option.fields.length; i < len; i++) {
-        if (typeof option.fields[i] !== "string" || option.fields[i].length === 0) {
-          throw new Error(`btree index "fields[${i}]" must be a non-empty string, got: ${JSON.stringify(option.fields[i])}`);
+      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);
+          }
         }
       }
-      return {
-        type: "btree",
-        fields: option.fields
-      };
     }
-    if (option.type === "fts") {
-      if (typeof option.fields !== "string" || option.fields.length === 0) {
-        throw new Error(`fts index requires a non-empty string "fields", got: ${JSON.stringify(option.fields)}`);
-      }
-      if (option.tokenizer === "ngram") {
-        if (typeof option.gramSize !== "number" || option.gramSize < 1) {
-          throw new Error(`fts ngram index requires a positive "gramSize" number, got: ${JSON.stringify(option.gramSize)}`);
+    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, []);
         }
-        return {
-          type: "fts",
-          fields: option.fields,
-          tokenizer: "ngram",
-          gramSize: option.gramSize
-        };
+        this.fieldToIndices.get(field).push(indexName);
       }
-      return {
-        type: "fts",
-        fields: option.fields,
-        tokenizer: "whitespace"
-      };
     }
-    throw new Error(`Unknown index type: ${option.type}`);
+    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;
   }
   /**
-   * Get all field names from an IndexMetaConfig.
+   * Register an index. If called before init(), queues it.
    */
-  getFieldsFromConfig(config) {
-    if (config.type === "btree") {
-      return config.fields;
-    }
-    if (config.type === "fts") {
-      return [config.fields];
+  async registerIndex(name, option, tx) {
+    if (!this.api.isDocInitialized) {
+      this.pendingCreateIndices.set(name, option);
+      return;
     }
-    return [];
+    await this.registerIndexRuntime(name, option, tx);
   }
   /**
-   * 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.
+   * Register an index at runtime (after init).
    */
-  getPrimaryField(config) {
-    if (config.type === "btree") {
-      return config.fields[0];
+  async registerIndexRuntime(name, option, tx) {
+    const config = this.toIndexMetaConfig(option);
+    if (this.registeredIndices.has(name)) {
+      throw new Error(`Index "${name}" already exists.`);
     }
-    return config.fields;
+    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.api.rowTableEngine.order,
+          this.api,
+          this.api.txContext,
+          name
+        ),
+        this.api.comparator
+      );
+      await tree.init();
+      this.trees.set(name, tree);
+      if (metadata.lastId > 0) {
+        this.pendingBackfillFields = [name];
+        await this.backfillIndices(tx2);
+      }
+    }, tx);
   }
   /**
-   * 인덱스 config에 따라 B+tree에 저장할 v 값을 생성합니다.
-   * - 단일 필드 btree: Primitive (단일 값)
-   * - 복합 필드 btree: Primitive[] (필드 순서대로 배열)
-   * - fts: 별도 처리 (이 메서드 사용 안 함)
-   * @returns undefined면 해당 문서에 필수 필드가 없으므로 인덱싱 스킵
+   * Drop (remove) a named index.
    */
-  getIndexValue(config, flatDoc) {
-    if (config.type !== "btree") return void 0;
-    if (config.fields.length === 1) {
-      const v = flatDoc[config.fields[0]];
-      return v === void 0 ? void 0 : v;
+  async dropIndex(name, tx) {
+    if (name === "_id") {
+      throw new Error('Cannot drop the "_id" index.');
     }
-    const values = [];
-    for (let i = 0, len = config.fields.length; i < len; i++) {
-      const v = flatDoc[config.fields[i]];
-      if (v === void 0) return void 0;
-      values.push(v);
+    if (!this.api.isDocInitialized) {
+      this.pendingCreateIndices.delete(name);
+      return;
     }
-    return values;
-  }
-  /**
-   * Get FTSConfig from IndexMetaConfig (for tokenizer compatibility).
-   */
-  getFtsConfig(config) {
-    if (config.type !== "fts") return null;
-    if (config.tokenizer === "ngram") {
-      return { type: "fts", tokenizer: "ngram", gramSize: config.gramSize };
+    if (!this.registeredIndices.has(name)) {
+      throw new Error(`Index "${name}" does not exist.`);
     }
-    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}`);
+    await this.api.runWithDefaultWrite(async (tx2) => {
+      const config = this.registeredIndices.get(name);
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
+      delete metadata.indices[name];
+      await this.api.updateDocumentInnerMetadata(metadata, tx2);
+      this.indices = metadata.indices;
+      this.registeredIndices.delete(name);
+      const fields = this.getFieldsFromConfig(config);
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        const indexNames = this.fieldToIndices.get(field);
+        if (indexNames) {
+          const filtered = indexNames.filter((n) => n !== name);
+          if (filtered.length === 0) {
+            this.fieldToIndices.delete(field);
+            if (field !== "_id") {
+              this.indexedFields.delete(field);
+            }
+          } else {
+            this.fieldToIndices.set(field, filtered);
+          }
+        }
       }
-      return JSON.parse(row);
+      this.trees.delete(name);
     }, 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) => {
+    return this.api.runWithDefaultWrite(async (tx2) => {
       if (this.pendingBackfillFields.length === 0) {
         return 0;
       }
       const backfillTargets = this.pendingBackfillFields;
-      const metadata = await this.getDocumentInnerMetadata(tx2);
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
       if (metadata.lastId === 0) {
         return 0;
       }
@@ -10964,9 +11472,9 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         primaryGte: { v: 0 }
       });
       for await (const [k, complexValue] of stream) {
-        const doc = await this.getDocument(k, tx2);
+        const doc = await this.api.getDocument(k, tx2);
         if (!doc) continue;
-        const flatDoc = this.flattenDocument(doc);
+        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;
@@ -11000,547 +11508,157 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         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);
-  }
-  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");
-    }
-    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;
-    }
-    const data = JSON.parse(row);
-    return data.magicString === "document-dataply" && data.version === 1;
-  }
-  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];
-      }
-    }
-    return result;
-  }
-  /**
-   * returns flattened document
-   * @param document
-   * @returns
-   */
-  flattenDocument(document) {
-    return this.flatten(document, "", {});
-  }
-  async getDocumentMetadata(tx) {
-    const metadata = await this.getMetadata(tx);
-    const innerMetadata = await this.getDocumentInnerMetadata(tx);
-    const indices = [];
-    for (const name of this.registeredIndices.keys()) {
-      if (name !== "_id") {
-        indices.push(name);
-      }
-    }
-    return {
-      pageSize: metadata.pageSize,
-      pageCount: metadata.pageCount,
-      rowCount: metadata.rowCount,
-      indices,
-      schemeVersion: innerMetadata.schemeVersion ?? 0
-    };
-  }
-  async getDocumentInnerMetadata(tx) {
-    const row = await this.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);
-  }
-  /**
-   * 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) => {
-      const innerMetadata = await this.getDocumentInnerMetadata(tx2);
-      const currentVersion = innerMetadata.schemeVersion ?? 0;
-      if (currentVersion < version) {
-        await callback(tx2);
-        const freshMetadata = await this.getDocumentInnerMetadata(tx2);
-        freshMetadata.schemeVersion = version;
-        freshMetadata.updatedAt = Date.now();
-        await this.updateDocumentInnerMetadata(freshMetadata, tx2);
-      }
-    }, 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 } };
-      } 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;
-  }
-  /**
-   * 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
-   */
-  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;
-      }
-      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;
+              await btx.commit();
+            }
+          } catch (err) {
+            for (const btx of Object.values(indexTxMap)) {
+              await btx.rollback();
+            }
+            throw err;
           }
-          if (!isBounded && field !== primaryField) {
-            compositeVerifyFields.push(field);
+          for (const indexName of backfillTargets) {
+            const tree = this.trees.get(indexName);
+            if (tree && indexName !== "_id") {
+              indexTxMap[indexName] = await tree.createTransaction();
+            }
           }
+          chunkCount = 0;
         }
-      } 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 (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;
         }
-        if (!isExactMatch) break;
-      }
-      if (isIndexOrderSupported) {
-        score += 200;
       }
-    }
-    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
-   */
-  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
-    };
+      this.pendingBackfillFields = [];
+      return backfilledCount;
+    }, 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
+   * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
    */
-  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);
-      }
+  toIndexMetaConfig(option) {
+    if (!option || typeof option !== "object") {
+      throw new Error("Index option must be a non-null object");
     }
-    const rollback = () => {
-      for (const { tree } of candidates) {
-        tree.rollback();
-      }
-    };
-    if (candidates.length === 0) {
-      rollback();
-      return null;
+    if (!option.type) {
+      throw new Error('Index option must have a "type" property ("btree" or "fts")');
     }
-    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] });
+    if (option.type === "btree") {
+      if (!Array.isArray(option.fields) || option.fields.length === 0) {
+        throw new Error('btree index requires a non-empty "fields" array');
+      }
+      for (let i = 0, len = option.fields.length; i < len; i++) {
+        if (typeof option.fields[i] !== "string" || option.fields[i].length === 0) {
+          throw new Error(`btree index "fields[${i}]" must be a non-empty string, got: ${JSON.stringify(option.fields[i])}`);
+        }
       }
+      return {
+        type: "btree",
+        fields: option.fields
+      };
     }
-    return {
-      driver,
-      others,
-      compositeVerifyConditions,
-      rollback
-    };
-  }
-  /**
-   * Get Free Memory Chunk Size
-   * @returns { verySmallChunkSize, smallChunkSize }
-   */
-  getFreeMemoryChunkSize() {
-    const freeMem = os.freemem();
-    const safeLimit = freeMem * 0.2;
-    const verySmallChunkSize = safeLimit * 0.05;
-    const smallChunkSize = safeLimit * 0.3;
-    return { verySmallChunkSize, smallChunkSize };
-  }
-  getTokenKey(pk, token) {
-    return pk + ":" + token;
-  }
-  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;
+    if (option.type === "fts") {
+      if (typeof option.fields !== "string" || option.fields.length === 0) {
+        throw new Error(`fts index requires a non-empty string "fields", got: ${JSON.stringify(option.fields)}`);
+      }
+      if (option.tokenizer === "ngram") {
+        if (typeof option.gramSize !== "number" || option.gramSize < 1) {
+          throw new Error(`fts ngram index requires a positive "gramSize" number, got: ${JSON.stringify(option.gramSize)}`);
         }
+        return {
+          type: "fts",
+          fields: option.fields,
+          tokenizer: "ngram",
+          gramSize: option.gramSize
+        };
       }
+      return {
+        type: "fts",
+        fields: option.fields,
+        tokenizer: "whitespace"
+      };
     }
+    throw new Error(`Unknown index type: ${option.type}`);
   }
   /**
-   * 특정 인덱스 후보를 조회하여 PK 집합을 필터링합니다.
-   */
-  applyCandidateStream(candidate, filterValues, order) {
-    return candidate.tree.keysStream(
-      candidate.condition,
-      { filterValues, order }
-    );
-  }
-  /**
-   * 쿼리와 인덱스 선택을 기반으로 기본 키(Primary Keys)를 가져옵니다.
-   * 쿼리 최적화를 통합하기 위한 내부 공통 메서드입니다.
+   * Get all field names from an IndexMetaConfig.
    */
-  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);
-      }
+  getFieldsFromConfig(config) {
+    if (config.type === "btree") {
+      return config.fields;
     }
-    rollback();
-    return new Float64Array(Array.from(keys || []));
+    if (config.type === "fts") {
+      return [config.fields];
+    }
+    return [];
   }
   /**
-   * 드라이버 인덱스만으로 PK 스트림을 가져옵니다. (교집합 없이)
-   * selectDocuments에서 사용하며, 나머지 조건(others)은 스트리밍 중 tree.verify()로 검증합니다.
-   * @returns 드라이버 키 스트림, others 후보 목록, rollback 함수. 또는 null.
+   * Get the primary field of an index.
    */
-  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);
+  getPrimaryField(config) {
+    if (config.type === "btree") {
+      return config.fields[0];
     }
-    return {
-      keysStream,
-      others,
-      compositeVerifyConditions,
-      isDriverOrderByField: useIndexOrder,
-      rollback
-    };
+    return config.fields;
+  }
+  /**
+   * Create B+Tree value string for indexing a document
+   */
+  getIndexValue(config, flatDoc) {
+    if (config.type !== "btree") return void 0;
+    if (config.fields.length === 1) {
+      const v = flatDoc[config.fields[0]];
+      return v === void 0 ? void 0 : v;
+    }
+    const values = [];
+    for (let i = 0, len = config.fields.length; i < len; i++) {
+      const v = flatDoc[config.fields[i]];
+      if (v === void 0) return void 0;
+      values.push(v);
+    }
+    return values;
+  }
+  /**
+   * Get FTSConfig from IndexMetaConfig
+   */
+  getFtsConfig(config) {
+    if (config.type !== "fts") return null;
+    if (config.tokenizer === "ngram") {
+      return { type: "fts", tokenizer: "ngram", gramSize: config.gramSize };
+    }
+    return { type: "fts", tokenizer: "whitespace" };
+  }
+  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.getDocumentInnerMetadata(tx);
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
     const id = ++metadata.lastId;
-    await this.updateDocumentInnerMetadata(metadata, tx);
+    await this.api.updateDocumentInnerMetadata(metadata, tx);
     const dataplyDocument = Object.assign({
       _id: id
     }, document);
-    const pk = await super.insert(JSON.stringify(dataplyDocument), true, tx);
+    const pk = await this.api.insert(JSON.stringify(dataplyDocument), true, tx);
     return {
       pk,
       id,
@@ -11554,26 +11672,26 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @returns The primary key of the inserted document
    */
   async insertSingleDocument(document, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
+    return this.api.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);
+      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.getPrimaryField(config);
+          const primaryField = this.api.indexManager.getPrimaryField(config);
           const v = flattenDocument[primaryField];
           if (v === void 0 || typeof v !== "string") continue;
-          const ftsConfig = this.getFtsConfig(config);
+          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.getTokenKey(dpk, token);
+            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.getIndexValue(config, flattenDocument);
+          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;
@@ -11589,11 +11707,11 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @returns The primary keys of the inserted documents
    */
   async insertBatchDocuments(documents, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      const metadata = await this.getDocumentInnerMetadata(tx2);
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
       const startId = metadata.lastId + 1;
       metadata.lastId += documents.length;
-      await this.updateDocumentInnerMetadata(metadata, tx2);
+      await this.api.updateDocumentInnerMetadata(metadata, tx2);
       const ids = [];
       const dataplyDocuments = [];
       const flattenedData = [];
@@ -11604,22 +11722,22 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         }, documents[i]);
         const stringified = JSON.stringify(dataplyDocument);
         dataplyDocuments.push(stringified);
-        const flattenDocument = this.flattenDocument(dataplyDocument);
+        const flattenDocument = this.api.flattenDocument(dataplyDocument);
         flattenedData.push({ pk: -1, data: flattenDocument });
         ids.push(id);
       }
-      const pks = await super.insertBatch(dataplyDocuments, true, tx2);
+      const pks = await this.api.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);
+      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.getPrimaryField(config);
-          const ftsConfig = this.getFtsConfig(config);
+          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];
@@ -11627,13 +11745,13 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
             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 }]);
+              batchInsertData.push([this.api.indexManager.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);
+            const indexVal = this.api.indexManager.getIndexValue(config, item.data);
             if (indexVal === void 0) continue;
             batchInsertData.push([item.pk, { k: item.pk, v: indexVal }]);
           }
@@ -11658,46 +11776,46 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @returns The number of updated documents
    */
   async updateInternal(query, computeUpdatedDoc, tx) {
-    const pks = await this.getKeys(query);
+    const pks = await this.api.queryManager.getKeys(query);
     let updatedCount = 0;
     const treeTxs = /* @__PURE__ */ new Map();
-    for (const [indexName, tree] of this.trees) {
+    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.getDocument(pk, tx);
+      const doc = await this.api.getDocument(pk, tx);
       if (!doc) continue;
       const updatedDoc = computeUpdatedDoc(doc);
-      const oldFlatDoc = this.flattenDocument(doc);
-      const newFlatDoc = this.flattenDocument(updatedDoc);
+      const oldFlatDoc = this.api.flattenDocument(doc);
+      const newFlatDoc = this.api.flattenDocument(updatedDoc);
       for (const [indexName, treeTx] of treeTxs) {
-        const config = this.registeredIndices.get(indexName);
+        const config = this.api.indexManager.registeredIndices.get(indexName);
         if (!config) continue;
         if (config.type === "fts") {
-          const primaryField = this.getPrimaryField(config);
+          const primaryField = this.api.indexManager.getPrimaryField(config);
           const oldV = oldFlatDoc[primaryField];
           const newV = newFlatDoc[primaryField];
           if (oldV === newV) continue;
-          const ftsConfig = this.getFtsConfig(config);
+          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.getTokenKey(pk, oldTokens[j]), { k: pk, v: oldTokens[j] });
+              await treeTx.delete(this.api.indexManager.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] }]);
+              batchInsertData.push([this.api.indexManager.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);
+          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 });
@@ -11707,7 +11825,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
           }
         }
       }
-      await this.update(pk, JSON.stringify(updatedDoc), tx);
+      await this.api.update(pk, JSON.stringify(updatedDoc), tx);
       updatedCount++;
     }
     for (const [indexName, treeTx] of treeTxs) {
@@ -11729,7 +11847,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @returns The number of updated documents
    */
   async fullUpdate(query, newRecord, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
+    return this.api.runWithDefaultWrite(async (tx2) => {
       return this.updateInternal(query, (doc) => {
         const newDoc = typeof newRecord === "function" ? newRecord(doc) : newRecord;
         return { _id: doc._id, ...newDoc };
@@ -11744,7 +11862,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @returns The number of updated documents
    */
   async partialUpdate(query, newRecord, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
+    return this.api.runWithDefaultWrite(async (tx2) => {
       return this.updateInternal(query, (doc) => {
         const partialUpdateContent = typeof newRecord === "function" ? newRecord(doc) : newRecord;
         const finalUpdate = { ...partialUpdateContent };
@@ -11760,189 +11878,300 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * @returns The number of deleted documents
    */
   async deleteDocuments(query, tx) {
-    return this.runWithDefaultWrite(async (tx2) => {
-      const pks = await this.getKeys(query);
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      const pks = await this.api.queryManager.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);
+        const doc = await this.api.getDocument(pk, tx2);
         if (!doc) continue;
-        const flatDoc = this.flattenDocument(doc);
-        for (const [indexName, tree] of this.trees) {
-          const config = this.registeredIndices.get(indexName);
+        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.getPrimaryField(config);
+            const primaryField = this.api.indexManager.getPrimaryField(config);
             const v = flatDoc[primaryField];
             if (v === void 0 || typeof v !== "string") continue;
-            const ftsConfig = this.getFtsConfig(config);
+            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.getTokenKey(pk, tokens[j]), { k: pk, v: tokens[j] });
+              await tree.delete(this.api.indexManager.getTokenKey(pk, tokens[j]), { k: pk, v: tokens[j] });
             }
           } else {
-            const indexVal = this.getIndexValue(config, flatDoc);
+            const indexVal = this.api.indexManager.getIndexValue(config, flatDoc);
             if (indexVal === void 0) continue;
             await tree.delete(pk, { k: pk, v: indexVal });
           }
         }
-        await super.delete(pk, true, tx2);
+        await this.api.delete(pk, true, tx2);
         deletedCount++;
       }
       return deletedCount;
     }, tx);
   }
+};
+
+// src/core/MetadataManager.ts
+var MetadataManager = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async getDocumentMetadata(tx) {
+    const metadata = await this.api.getMetadata(tx);
+    const innerMetadata = await this.getDocumentInnerMetadata(tx);
+    const indices = [];
+    for (const name of this.api.indexManager.registeredIndices.keys()) {
+      if (name !== "_id") {
+        indices.push(name);
+      }
+    }
+    return {
+      pageSize: metadata.pageSize,
+      pageCount: metadata.pageCount,
+      rowCount: metadata.rowCount,
+      usage: metadata.usage,
+      indices,
+      schemeVersion: innerMetadata.schemeVersion ?? 0
+    };
+  }
+  async getDocumentInnerMetadata(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.api.update(1, JSON.stringify(metadata), tx);
+  }
   /**
-   * 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
+   * 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 countDocuments(query, tx) {
+  async migration(version, callback, tx) {
+    await this.api.runWithDefaultWrite(async (tx2) => {
+      const innerMetadata = await this.getDocumentInnerMetadata(tx2);
+      const currentVersion = innerMetadata.schemeVersion ?? 0;
+      if (currentVersion < version) {
+        await callback(tx2);
+        const freshMetadata = await this.getDocumentInnerMetadata(tx2);
+        freshMetadata.schemeVersion = version;
+        freshMetadata.updatedAt = Date.now();
+        await this.updateDocumentInnerMetadata(freshMetadata, tx2);
+      }
+    }, tx);
+  }
+};
+
+// 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 {
+        result[newKey] = obj[key];
+      }
+    }
+    return result;
+  }
+  /**
+   * returns flattened document
+   * @param document
+   * @returns
+   */
+  flattenDocument(document) {
+    return this.flattenInternal(document, "", {});
+  }
+};
+
+// src/core/documentAPI.ts
+var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
+  comparator = new DocumentValueComparator();
+  _initialized = false;
+  optimizer;
+  queryManager;
+  indexManager;
+  mutationManager;
+  metadataManager;
+  documentFormatter;
+  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.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._initialized = true;
+      return tx;
+    });
+  }
+  /**
+   * Whether the document database has been initialized.
+   */
+  get isDocInitialized() {
+    return this._initialized;
+  }
+  get indices() {
+    return this.indexManager.indices;
+  }
+  get trees() {
+    return this.indexManager.trees;
+  }
+  get indexedFields() {
+    return this.indexManager.indexedFields;
+  }
+  async registerIndex(name, option, tx) {
+    return this.indexManager.registerIndex(name, option, tx);
+  }
+  /**
+   * Drop (remove) a named index.
+   */
+  async dropIndex(name, tx) {
+    return this.indexManager.dropIndex(name, tx);
+  }
+  async getDocument(pk, tx) {
     return this.runWithDefault(async (tx2) => {
-      const pks = await this.getKeys(query);
-      return pks.length;
+      const row = await this.select(pk, false, tx2);
+      if (!row) {
+        throw new Error(`Document not found with PK: ${pk}`);
+      }
+      return JSON.parse(row);
     }, tx);
   }
   /**
-   * FTS 조건에 대해 문서가 유효한지 검증합니다.
+   * Backfill indices for newly created indices after data was inserted.
+   * Delegated to IndexManager.
+   */
+  async backfillIndices(tx) {
+    return this.indexManager.backfillIndices(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");
+    }
+    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;
+    }
+    const data = JSON.parse(row);
+    return data.magicString === "document-dataply" && data.version === 1;
+  }
+  /**
+   * returns flattened document
+   * @param document
+   * @returns
+   */
+  flattenDocument(document) {
+    return this.documentFormatter.flattenDocument(document);
+  }
+  async getDocumentMetadata(tx) {
+    return this.metadataManager.getDocumentMetadata(tx);
+  }
+  async getDocumentInnerMetadata(tx) {
+    return this.metadataManager.getDocumentInnerMetadata(tx);
+  }
+  async updateDocumentInnerMetadata(metadata, tx) {
+    return this.metadataManager.updateDocumentInnerMetadata(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) {
+    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 primary key of the inserted document
+   */
+  async insertSingleDocument(document, tx) {
+    return this.mutationManager.insertSingleDocument(document, tx);
+  }
+  /**
+   * 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 isInfiniteLimit = isFinite(limit);
-    let currentChunkSize = isInfiniteLimit ? initialChunkSize : limit;
-    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 (isInfiniteLimit) {
-        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
@@ -11953,130 +12182,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);
   }
 };
 
@@ -12248,7 +12354,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,