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

package/dist/cjs/index.js

@@ -10616,6 +10616,7 @@ var Optimizer = class {
   }
   /**
    * FTS 타입 인덱스의 선택도를 평가합니다.
+   * FTSTermCount 통계가 있으면 토큰 빈도 기반 동적 score를 산출합니다.
    */
   evaluateFTSCandidate(indexName, config, query, queryFields, treeTx) {
     const field = config.fields;
@@ -10624,6 +10625,20 @@ var Optimizer = class {
     if (!condition || typeof condition !== "object" || !("match" in condition)) return null;
     const ftsConfig = this.api.indexManager.getFtsConfig(config);
     const matchTokens = ftsConfig ? tokenize(condition.match, ftsConfig) : [];
+    const MAX_FTS_SCORE = 400;
+    const MIN_FTS_SCORE = 10;
+    const DEFAULT_FTS_SCORE = 90;
+    let score = DEFAULT_FTS_SCORE;
+    const termCountProvider = this.api.analysisManager.getProvider("fts_term_count");
+    if (termCountProvider && termCountProvider.hasSampleData && ftsConfig && matchTokens.length > 0) {
+      const strategy = ftsConfig.tokenizer === "ngram" ? `${ftsConfig.gramSize}gram` : ftsConfig.tokenizer;
+      const minCount = termCountProvider.getMinTokenCount(field, strategy, matchTokens);
+      if (minCount >= 0) {
+        const sampleSize = termCountProvider.getSampleSize();
+        const selectivityRatio = Math.min(minCount / sampleSize, 1);
+        score = Math.round(MAX_FTS_SCORE * (1 - selectivityRatio) + MIN_FTS_SCORE);
+      }
+    }
     return {
       tree: treeTx,
       condition,
@@ -10631,7 +10646,7 @@ var Optimizer = class {
       indexName,
       isFtsMatch: true,
       matchTokens,
-      score: 90,
+      score,
       compositeVerifyFields: [],
       coveredFields: [field],
       isIndexOrderSupported: false
@@ -10688,7 +10703,20 @@ var Optimizer = class {
     });
     const driver = candidates[0];
     const driverCoveredFields = new Set(driver.coveredFields);
-    const others = candidates.slice(1).filter((c) => !driverCoveredFields.has(c.field));
+    const nonDriverCandidates = candidates.slice(1).filter((c) => !driverCoveredFields.has(c.field));
+    const others = [];
+    for (let i = 0, len = nonDriverCandidates.length; i < len; i++) {
+      const candidate = nonDriverCandidates[i];
+      let isSubset = false;
+      for (let j = 0, oLen = others.length; j < oLen; j++) {
+        const higher = others[j];
+        if (candidate.coveredFields.every((f) => higher.coveredFields.includes(f))) {
+          isSubset = true;
+          break;
+        }
+      }
+      if (!isSubset) others.push(candidate);
+    }
     const compositeVerifyConditions = [];
     for (let i = 0, len = driver.compositeVerifyFields.length; i < len; i++) {
       const field = driver.compositeVerifyFields[i];
@@ -10981,7 +11009,10 @@ var QueryManager = class {
     const isCompositeVerify = compositeVerifyConditions.length > 0;
     const isVerifyOthers = verifyOthers.length > 0;
     const isInfinityLimit = !isFinite(limit);
-    const isReadQuotaLimited = !isInfinityLimit || !isCompositeVerify || !isVerifyOthers || !isFts;
+    const isReadQuotaLimited = !isInfinityLimit && // limit이 임의의 유한한 값으로 설정되어 있으며
+    !isCompositeVerify && // 문서를 가져온 후 복합 인덱스 기준으로 2차 필터링할 필요가 없고
+    !isVerifyOthers && // 문서를 가져온 후 다른 인덱스 기준으로 2차 필터링할 필요가 없으며
+    !isFts;
     let currentChunkSize = isReadQuotaLimited ? limit : initialChunkSize;
     let chunk = [];
     let chunkSize = 0;
@@ -11002,10 +11033,30 @@ var QueryManager = class {
           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 coveredFields = other.coveredFields;
+            let fieldValue;
+            if (coveredFields && coveredFields.length > 1) {
+              const values = [];
+              let hasMissing = false;
+              for (let f = 0, fLen = coveredFields.length; f < fLen; f++) {
+                const v = flatDoc[coveredFields[f]];
+                if (v === void 0) {
+                  hasMissing = true;
+                  break;
+                }
+                values.push(v);
+              }
+              if (hasMissing) {
+                passed = false;
+                break;
+              }
+              fieldValue = values;
+            } else {
+              fieldValue = flatDoc[other.field];
+              if (fieldValue === void 0) {
+                passed = false;
+                break;
+              }
             }
             const treeValue = { k: doc._id, v: fieldValue };
             if (!other.tree.verify(treeValue, other.condition)) {
@@ -11665,12 +11716,6 @@ var MutationManager = class {
       document: dataplyDocument
     };
   }
-  /**
-   * 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.api.runWithDefaultWrite(async (tx2) => {
       const { pk: dpk, document: dataplyDocument } = await this.insertDocumentInternal(document, tx2);
@@ -11697,15 +11742,10 @@ var MutationManager = class {
           if (error) throw error;
         }
       }
+      await this.api.analysisManager.notifyInsert([flattenDocument], tx2);
       return dataplyDocument._id;
     }, 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
-   */
   async insertBatchDocuments(documents, tx) {
     return this.api.runWithDefaultWrite(async (tx2) => {
       const metadata = await this.api.getDocumentInnerMetadata(tx2);
@@ -11765,19 +11805,18 @@ var MutationManager = class {
           throw res.error;
         }
       }
+      const flatDocs = [];
+      for (let i = 0, len = flattenedData.length; i < len; i++) {
+        flatDocs.push(flattenedData[i].data);
+      }
+      await this.api.analysisManager.notifyInsert(flatDocs, tx2);
       return ids;
     }, tx);
   }
-  /**
-   * Internal update method used by both fullUpdate and partialUpdate
-   * @param query The query to use
-   * @param computeUpdatedDoc Function that computes the updated document from the original
-   * @param tx The transaction to use
-   * @returns The number of updated documents
-   */
   async updateInternal(query, computeUpdatedDoc, tx) {
     const pks = await this.api.queryManager.getKeys(query);
     let updatedCount = 0;
+    const updatePairs = [];
     const treeTxs = /* @__PURE__ */ new Map();
     for (const [indexName, tree] of this.api.trees) {
       treeTxs.set(indexName, await tree.createTransaction());
@@ -11825,6 +11864,7 @@ var MutationManager = class {
           }
         }
       }
+      updatePairs.push({ oldDocument: oldFlatDoc, newDocument: newFlatDoc });
       await this.api.update(pk, JSON.stringify(updatedDoc), tx);
       updatedCount++;
     }
@@ -11837,15 +11877,9 @@ var MutationManager = class {
         throw result.error;
       }
     }
+    await this.api.analysisManager.notifyUpdate(updatePairs, tx);
     return updatedCount;
   }
-  /**
-   * 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
-   */
   async fullUpdate(query, newRecord, tx) {
     return this.api.runWithDefaultWrite(async (tx2) => {
       return this.updateInternal(query, (doc) => {
@@ -11854,13 +11888,6 @@ var MutationManager = class {
       }, tx2);
     }, tx);
   }
-  /**
-   * Partially update documents from the database that match the query
-   * @param query The query to use
-   * @param newRecord Partial document to merge, or function that receives current document and returns partial update
-   * @param tx The transaction to use
-   * @returns The number of updated documents
-   */
   async partialUpdate(query, newRecord, tx) {
     return this.api.runWithDefaultWrite(async (tx2) => {
       return this.updateInternal(query, (doc) => {
@@ -11871,16 +11898,11 @@ var MutationManager = class {
       }, tx2);
     }, 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
-   */
   async deleteDocuments(query, tx) {
     return this.api.runWithDefaultWrite(async (tx2) => {
       const pks = await this.api.queryManager.getKeys(query);
       let deletedCount = 0;
+      const deletedFlatDocs = [];
       for (let i = 0, len = pks.length; i < len; i++) {
         const pk = pks[i];
         const doc = await this.api.getDocument(pk, tx2);
@@ -11904,9 +11926,11 @@ var MutationManager = class {
             await tree.delete(pk, { k: pk, v: indexVal });
           }
         }
+        deletedFlatDocs.push(flatDoc);
         await this.api.delete(pk, true, tx2);
         deletedCount++;
       }
+      await this.api.analysisManager.notifyDelete(deletedFlatDocs, tx2);
       return deletedCount;
     }, tx);
   }
@@ -11945,13 +11969,6 @@ var MetadataManager = class {
   async updateDocumentInnerMetadata(metadata, tx) {
     await this.api.update(1, JSON.stringify(metadata), tx);
   }
-  /**
-   * Run a migration if the current schemeVersion is lower than the target version.
-   * After the callback completes, schemeVersion is updated to the target version.
-   * @param version The target scheme version
-   * @param callback The migration callback
-   * @param tx Optional transaction
-   */
   async migration(version, callback, tx) {
     await this.api.runWithDefaultWrite(async (tx2) => {
       const innerMetadata = await this.getDocumentInnerMetadata(tx2);
@@ -11980,16 +11997,392 @@ var DocumentFormatter = class {
     }
     return result;
   }
-  /**
-   * returns flattened document
-   * @param document
-   * @returns
-   */
   flattenDocument(document) {
     return this.flattenInternal(document, "", {});
   }
 };
 
+// src/core/AnalysisProvider.ts
+var AnalysisProvider = class {
+  constructor(api) {
+    this.api = api;
+  }
+  /** Overflow row PK assigned by AnalysisManager during initialization. */
+  storageKey = -1;
+};
+
+// src/core/RealtimeAnalysisProvider.ts
+var RealtimeAnalysisProvider = class extends AnalysisProvider {
+};
+
+// src/core/IntervalAnalysisProvider.ts
+var IntervalAnalysisProvider = class extends AnalysisProvider {
+  /**
+   * Sample random documents from the entire dataset.
+   * Fetches only PK index, then reads only the selected documents from disk.
+   * @param sampleOptions Sampling strategy — either `{ rate }` or `{ count }`
+   * @param tx Optional transaction
+   * @returns Randomly selected documents
+   */
+  async sample(sampleOptions, tx) {
+    const pks = await this.api.queryManager.getKeys({});
+    const total = pks.length;
+    if (total === 0) return [];
+    const k = "rate" in sampleOptions && sampleOptions.rate != null ? Math.ceil(total * Math.min(Math.max(sampleOptions.rate, 0), 1)) : sampleOptions.count;
+    const sampleCount = Math.min(Math.max(k, 0), total);
+    if (sampleCount === 0) return [];
+    for (let i = 0; i < sampleCount; i++) {
+      const j = i + Math.floor(Math.random() * (total - i));
+      const tmp = pks[i];
+      pks[i] = pks[j];
+      pks[j] = tmp;
+    }
+    const selectedPks = pks.slice(0, sampleCount);
+    const rawResults = await this.api.selectMany(selectedPks, false, tx);
+    const docs = [];
+    for (let i = 0, len = rawResults.length; i < len; i++) {
+      const raw = rawResults[i];
+      if (raw) docs.push(JSON.parse(raw));
+    }
+    return docs;
+  }
+};
+
+// src/core/analysis/FTSTermCount.ts
+var FTSTermCount = class extends IntervalAnalysisProvider {
+  name = "fts_term_count";
+  termCount = {};
+  sampleSize = 0;
+  async serialize(tx) {
+    const docs = await this.sample({ count: 1e3 }, tx);
+    this.termCount = {};
+    this.sampleSize = docs.length;
+    if (docs.length === 0) return JSON.stringify({ _sampleSize: 0 });
+    const ftsIndices = /* @__PURE__ */ new Map();
+    for (const [indexName, config] of this.api.indexManager.registeredIndices) {
+      if (config.type === "fts") {
+        ftsIndices.set(indexName, config);
+      }
+    }
+    if (ftsIndices.size === 0) return JSON.stringify({ _sampleSize: this.sampleSize });
+    for (let i = 0, len = docs.length; i < len; i++) {
+      const doc = docs[i];
+      const flatDoc = this.api.flattenDocument(doc);
+      for (const [indexName, config] of ftsIndices) {
+        const primaryField = this.api.indexManager.getPrimaryField(config);
+        const v = flatDoc[primaryField];
+        if (typeof v === "string" && v.length > 0) {
+          const ftsConfig = this.api.indexManager.getFtsConfig(config);
+          const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
+          const tokenizerStrategy = ftsConfig ? ftsConfig.tokenizer === "ngram" ? `${ftsConfig.gramSize}gram` : ftsConfig.tokenizer : "whitespace";
+          if (!this.termCount[primaryField]) {
+            this.termCount[primaryField] = {};
+          }
+          if (!this.termCount[primaryField][tokenizerStrategy]) {
+            this.termCount[primaryField][tokenizerStrategy] = {};
+          }
+          const targetMap = this.termCount[primaryField][tokenizerStrategy];
+          for (let j = 0, len2 = tokens.length; j < len2; j++) {
+            const token = tokens[j];
+            targetMap[token] = (targetMap[token] || 0) + 1;
+          }
+        }
+      }
+    }
+    const optimizedTermCount = {};
+    for (const field in this.termCount) {
+      optimizedTermCount[field] = {};
+      for (const strategy in this.termCount[field]) {
+        const tokenMap = this.termCount[field][strategy];
+        const sorted = Object.entries(tokenMap).sort((a, b) => b[1] - a[1]).slice(0, 1e3);
+        optimizedTermCount[field][strategy] = {};
+        for (let i = 0, len = sorted.length; i < len; i++) {
+          optimizedTermCount[field][strategy][sorted[i][0]] = sorted[i][1];
+        }
+      }
+    }
+    this.termCount = optimizedTermCount;
+    return JSON.stringify({ _sampleSize: this.sampleSize, ...this.termCount });
+  }
+  async load(data, tx) {
+    this.termCount = {};
+    this.sampleSize = 0;
+    if (!data) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        const { _sampleSize, ...rest } = parsed;
+        this.sampleSize = typeof _sampleSize === "number" ? _sampleSize : 0;
+        this.termCount = rest;
+      }
+    } catch (e) {
+    }
+  }
+  /**
+   * 특정 field/strategy/token의 문서 빈도를 반환합니다.
+   * 통계에 없으면 0을 반환합니다.
+   */
+  getTermCount(field, strategy, token) {
+    return this.termCount[field]?.[strategy]?.[token] ?? 0;
+  }
+  /**
+   * 쿼리 토큰 배열에서 최소 빈도(AND 시맨틱스 상한선)를 반환합니다.
+   * 통계가 없거나 sampleSize가 0이면 -1을 반환합니다.
+   */
+  getMinTokenCount(field, strategy, tokens) {
+    if (this.sampleSize === 0 || tokens.length === 0) return -1;
+    let minCount = Infinity;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const count = this.getTermCount(field, strategy, tokens[i]);
+      if (count < minCount) minCount = count;
+    }
+    return minCount === Infinity ? -1 : minCount;
+  }
+  /**
+   * 통계가 유효한지 여부를 반환합니다.
+   */
+  get hasSampleData() {
+    return this.sampleSize > 0;
+  }
+  /**
+   * 통계 수집 시 사용된 샘플 크기를 반환합니다.
+   */
+  getSampleSize() {
+    return this.sampleSize;
+  }
+};
+
+// src/core/analysis/index.ts
+var BuiltinAnalysisProviders = [
+  FTSTermCount
+];
+
+// src/core/AnalysisManager.ts
+var AnalysisManager = class {
+  constructor(api) {
+    this.api = api;
+  }
+  providers = /* @__PURE__ */ new Map();
+  /**
+   * Register all built-in analysis providers.
+   * Each provider class is instantiated with the API reference and registered.
+   */
+  registerBuiltinProviders() {
+    for (const Provider of BuiltinAnalysisProviders) {
+      const instance = new Provider(this.api);
+      this.registerProvider(instance);
+    }
+  }
+  /**
+   * Register an analysis provider.
+   * @param provider The provider instance to register
+   */
+  registerProvider(provider) {
+    if (this.providers.has(provider.name)) {
+      throw new Error(`Analysis provider "${provider.name}" is already registered.`);
+    }
+    this.providers.set(provider.name, provider);
+  }
+  /**
+   * Get a registered analysis provider by name.
+   * @param name The provider name
+   * @returns The provider instance, or null if not found
+   */
+  getProvider(name) {
+    return this.providers.get(name) ?? null;
+  }
+  /**
+   * Initialize all registered providers by loading existing data from disk.
+   * Should be called after database initialization.
+   * @param tx The transaction to use
+   */
+  async initializeProviders(tx) {
+    const header = await this.getOrCreateAnalysisHeader(tx);
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    for (const [name, provider] of this.providers) {
+      if (header[name] !== null) {
+        provider.storageKey = header[name];
+        const raw = await this.api.select(header[name], false, tx);
+        await provider.load(raw, tx);
+      } else {
+        const pk = await this.api.insertAsOverflow(JSON.stringify(null), false, tx);
+        provider.storageKey = pk;
+        header[name] = pk;
+        await this.api.update(metadata.analysis, JSON.stringify(header), tx);
+        await provider.load(null, tx);
+      }
+    }
+  }
+  /**
+   * Notify all realtime providers that documents were inserted.
+   * Data is persisted immediately after each provider processes the mutation.
+   * @param documents The flattened documents that were inserted
+   * @param tx The transaction to use
+   */
+  async notifyInsert(documents, tx) {
+    if (documents.length === 0) return;
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof RealtimeAnalysisProvider) {
+        await provider.onInsert(documents);
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
+      }
+    }
+  }
+  /**
+   * Notify all realtime providers that documents were deleted.
+   * Data is persisted immediately after each provider processes the mutation.
+   * @param documents The flattened documents that were deleted
+   * @param tx The transaction to use
+   */
+  async notifyDelete(documents, tx) {
+    if (documents.length === 0) return;
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof RealtimeAnalysisProvider) {
+        await provider.onDelete(documents);
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
+      }
+    }
+  }
+  /**
+   * Notify all realtime providers that documents were updated.
+   * Data is persisted immediately after each provider processes the mutation.
+   * @param pairs Array of { oldDocument, newDocument } pairs
+   * @param tx The transaction to use
+   */
+  async notifyUpdate(pairs, tx) {
+    if (pairs.length === 0) return;
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof RealtimeAnalysisProvider) {
+        await provider.onUpdate(pairs);
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
+      }
+    }
+  }
+  /**
+   * Flush all interval providers' data to disk.
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async flush(tx) {
+    for (const [name, provider] of this.providers) {
+      if (provider instanceof IntervalAnalysisProvider) {
+        await this.setAnalysisData(name, await provider.serialize(tx), tx);
+      }
+    }
+  }
+  /**
+   * Get the analysis header row.
+   * Returns null if no analysis header exists yet.
+   * @param tx The transaction to use
+   */
+  async getAnalysisHeader(tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (metadata.analysis == null) {
+      return null;
+    }
+    const row = await this.api.select(metadata.analysis, false, tx);
+    if (!row) {
+      return null;
+    }
+    return JSON.parse(row);
+  }
+  /**
+   * Get the analysis header row, creating it if it doesn't exist.
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async getOrCreateAnalysisHeader(tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (metadata.analysis != null) {
+      const row = await this.api.select(metadata.analysis, false, tx);
+      if (row) {
+        return JSON.parse(row);
+      }
+    }
+    const header = {};
+    const pk = await this.api.insertAsOverflow(JSON.stringify(header), false, tx);
+    metadata.analysis = pk;
+    await this.api.updateDocumentInnerMetadata(metadata, tx);
+    return header;
+  }
+  /**
+   * Get analysis data for a specific type as a raw string.
+   * Returns null if the type doesn't exist in the analysis header.
+   * @param type The analysis type name
+   * @param tx The transaction to use
+   */
+  async getAnalysisData(type, tx) {
+    const header = await this.getAnalysisHeader(tx);
+    if (!header || header[type] == null) {
+      return null;
+    }
+    const row = await this.api.select(header[type], false, tx);
+    if (!row) {
+      return null;
+    }
+    return row;
+  }
+  /**
+   * Set analysis data for a specific type.
+   * Creates a new overflow row if the type doesn't exist yet,
+   * or updates the existing row if it does.
+   * @param type The analysis type name
+   * @param data The raw string data to store
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async setAnalysisData(type, data, tx) {
+    const header = await this.getOrCreateAnalysisHeader(tx);
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (header[type] != null) {
+      await this.api.update(header[type], data, tx);
+    } else {
+      const pk = await this.api.insertAsOverflow(data, false, tx);
+      header[type] = pk;
+      await this.api.update(metadata.analysis, JSON.stringify(header), tx);
+    }
+  }
+  /**
+   * Delete analysis data for a specific type.
+   * Removes the type entry from the analysis header.
+   * @param type The analysis type name
+   * @param tx The transaction to use (must be a write transaction)
+   */
+  async deleteAnalysisData(type, tx) {
+    const metadata = await this.api.getDocumentInnerMetadata(tx);
+    if (metadata.analysis == null) {
+      return false;
+    }
+    const header = await this.getAnalysisHeader(tx);
+    if (!header || header[type] == null) {
+      return false;
+    }
+    await this.api.delete(header[type], false, tx);
+    delete header[type];
+    await this.api.update(metadata.analysis, JSON.stringify(header), tx);
+    return true;
+  }
+  /**
+   * Check if analysis data exists for a specific type.
+   * @param type The analysis type name
+   * @param tx The transaction to use
+   */
+  async hasAnalysisData(type, tx) {
+    const header = await this.getAnalysisHeader(tx);
+    return header != null && header[type] != null;
+  }
+  /**
+   * Get all registered analysis type names.
+   * @param tx The transaction to use
+   */
+  async getAnalysisTypes(tx) {
+    const header = await this.getAnalysisHeader(tx);
+    if (!header) {
+      return [];
+    }
+    return Object.keys(header);
+  }
+};
+
 // src/core/documentAPI.ts
 var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   comparator = new DocumentValueComparator();
@@ -12000,6 +12393,7 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   mutationManager;
   metadataManager;
   documentFormatter;
+  analysisManager;
   constructor(file, options) {
     super(file, options);
     this.optimizer = new Optimizer(this);
@@ -12008,6 +12402,7 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
     this.mutationManager = new MutationManager(this);
     this.metadataManager = new MetadataManager(this);
     this.documentFormatter = new DocumentFormatter();
+    this.analysisManager = new AnalysisManager(this);
     this.hook.onceAfter("init", async (tx, isNewlyCreated) => {
       if (isNewlyCreated) {
         await this.initializeDocumentFile(tx);
@@ -12017,6 +12412,8 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
       }
       const metadata = await this.getDocumentInnerMetadata(tx);
       await this.indexManager.initializeIndices(metadata, isNewlyCreated, tx);
+      this.analysisManager.registerBuiltinProviders();
+      await this.analysisManager.initializeProviders(tx);
       this._initialized = true;
       return tx;
     });
@@ -12036,15 +12433,29 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   get indexedFields() {
     return this.indexManager.indexedFields;
   }
+  /**
+   * Register an index.
+   * @param name The name of the index
+   * @param option The option of the index
+   * @param tx The transaction to use
+   */
   async registerIndex(name, option, tx) {
     return this.indexManager.registerIndex(name, option, tx);
   }
   /**
    * Drop (remove) a named index.
+   * @param name The name of the index
+   * @param tx The transaction to use
    */
   async dropIndex(name, tx) {
     return this.indexManager.dropIndex(name, tx);
   }
+  /**
+   * Get a document by its primary key.
+   * @param pk The primary key of the document
+   * @param tx The transaction to use
+   * @returns The document
+   */
   async getDocument(pk, tx) {
     return this.runWithDefault(async (tx2) => {
       const row = await this.select(pk, false, tx2);
@@ -12061,6 +12472,16 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   async backfillIndices(tx) {
     return this.indexManager.backfillIndices(tx);
   }
+  /**
+   * Flush all interval analysis providers, forcing statistics to be recalculated.
+   * Call this after bulk inserts or periodically to keep statistics fresh.
+   * @param tx The transaction to use
+   */
+  async flushAnalysis(tx) {
+    return this.runWithDefaultWrite(async (tx2) => {
+      await this.analysisManager.flush(tx2);
+    }, tx);
+  }
   createDocumentInnerMetadata(indices) {
     return {
       magicString: "document-dataply",
@@ -12072,16 +12493,28 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
       indices
     };
   }
+  /**
+   * Initialize the document database file.
+   * @param tx The transaction to use
+   */
   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"] }]
+      _id: [-1, {
+        type: "btree",
+        fields: ["_id"]
+      }]
     });
     await this.insertAsOverflow(JSON.stringify(metaObj), false, tx);
   }
+  /**
+   * Verify the document database file.
+   * @param tx The transaction to use
+   * @returns True if the document database file is valid, false otherwise
+   */
   async verifyDocumentFile(tx) {
     const row = await this.select(1, false, tx);
     if (!row) {
@@ -12098,12 +12531,27 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   flattenDocument(document) {
     return this.documentFormatter.flattenDocument(document);
   }
+  /**
+   * Get the document metadata.
+   * @param tx The transaction to use
+   * @returns The document metadata
+   */
   async getDocumentMetadata(tx) {
     return this.metadataManager.getDocumentMetadata(tx);
   }
+  /**
+   * Get the document inner metadata.
+   * @param tx The transaction to use
+   * @returns The document inner metadata
+   */
   async getDocumentInnerMetadata(tx) {
     return this.metadataManager.getDocumentInnerMetadata(tx);
   }
+  /**
+   * Update the document inner metadata.
+   * @param metadata The document inner metadata
+   * @param tx The transaction to use
+   */
   async updateDocumentInnerMetadata(metadata, tx) {
     return this.metadataManager.updateDocumentInnerMetadata(metadata, tx);
   }
@@ -12255,6 +12703,14 @@ var DocumentDataply = class _DocumentDataply {
     await this.api.init();
     await this.api.backfillIndices();
   }
+  /**
+   * Flush all interval analysis providers, forcing statistics to be recalculated.
+   * Call this after bulk inserts or periodically to keep FTS statistics fresh.
+   * @param tx Optional transaction
+   */
+  async flushAnalysis(tx) {
+    return this.api.flushAnalysis(tx);
+  }
   /**
    * Run a migration if the current schemeVersion is lower than the target version.
    * The callback is only executed when the database's schemeVersion is below the given version.

package/dist/types/core/AnalysisManager.d.ts

@@ -0,0 +1,105 @@
+import type { AnalysisHeader, DocumentJSON, FlattenedDocumentJSON } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import type { AnalysisProvider } from './AnalysisProvider';
+import { Transaction } from 'dataply';
+export declare class AnalysisManager<T extends DocumentJSON> {
+    private api;
+    private providers;
+    constructor(api: DocumentDataplyAPI<T>);
+    /**
+     * Register all built-in analysis providers.
+     * Each provider class is instantiated with the API reference and registered.
+     */
+    registerBuiltinProviders(): void;
+    /**
+     * Register an analysis provider.
+     * @param provider The provider instance to register
+     */
+    registerProvider(provider: AnalysisProvider<T>): void;
+    /**
+     * Get a registered analysis provider by name.
+     * @param name The provider name
+     * @returns The provider instance, or null if not found
+     */
+    getProvider<P extends AnalysisProvider<T> = AnalysisProvider<T>>(name: string): P | null;
+    /**
+     * Initialize all registered providers by loading existing data from disk.
+     * Should be called after database initialization.
+     * @param tx The transaction to use
+     */
+    initializeProviders(tx: Transaction): Promise<void>;
+    /**
+     * Notify all realtime providers that documents were inserted.
+     * Data is persisted immediately after each provider processes the mutation.
+     * @param documents The flattened documents that were inserted
+     * @param tx The transaction to use
+     */
+    notifyInsert(documents: FlattenedDocumentJSON[], tx: Transaction): Promise<void>;
+    /**
+     * Notify all realtime providers that documents were deleted.
+     * Data is persisted immediately after each provider processes the mutation.
+     * @param documents The flattened documents that were deleted
+     * @param tx The transaction to use
+     */
+    notifyDelete(documents: FlattenedDocumentJSON[], tx: Transaction): Promise<void>;
+    /**
+     * Notify all realtime providers that documents were updated.
+     * Data is persisted immediately after each provider processes the mutation.
+     * @param pairs Array of { oldDocument, newDocument } pairs
+     * @param tx The transaction to use
+     */
+    notifyUpdate(pairs: {
+        oldDocument: FlattenedDocumentJSON;
+        newDocument: FlattenedDocumentJSON;
+    }[], tx: Transaction): Promise<void>;
+    /**
+     * Flush all interval providers' data to disk.
+     * @param tx The transaction to use (must be a write transaction)
+     */
+    flush(tx: Transaction): Promise<void>;
+    /**
+     * Get the analysis header row.
+     * Returns null if no analysis header exists yet.
+     * @param tx The transaction to use
+     */
+    getAnalysisHeader(tx: Transaction): Promise<AnalysisHeader | null>;
+    /**
+     * Get the analysis header row, creating it if it doesn't exist.
+     * @param tx The transaction to use (must be a write transaction)
+     */
+    getOrCreateAnalysisHeader(tx: Transaction): Promise<AnalysisHeader>;
+    /**
+     * Get analysis data for a specific type as a raw string.
+     * Returns null if the type doesn't exist in the analysis header.
+     * @param type The analysis type name
+     * @param tx The transaction to use
+     */
+    getAnalysisData(type: string, tx: Transaction): Promise<string | null>;
+    /**
+     * Set analysis data for a specific type.
+     * Creates a new overflow row if the type doesn't exist yet,
+     * or updates the existing row if it does.
+     * @param type The analysis type name
+     * @param data The raw string data to store
+     * @param tx The transaction to use (must be a write transaction)
+     */
+    setAnalysisData(type: string, data: string, tx: Transaction): Promise<void>;
+    /**
+     * Delete analysis data for a specific type.
+     * Removes the type entry from the analysis header.
+     * @param type The analysis type name
+     * @param tx The transaction to use (must be a write transaction)
+     */
+    deleteAnalysisData(type: string, tx: Transaction): Promise<boolean>;
+    /**
+     * Check if analysis data exists for a specific type.
+     * @param type The analysis type name
+     * @param tx The transaction to use
+     */
+    hasAnalysisData(type: string, tx: Transaction): Promise<boolean>;
+    /**
+     * Get all registered analysis type names.
+     * @param tx The transaction to use
+     */
+    getAnalysisTypes(tx: Transaction): Promise<string[]>;
+}

package/dist/types/core/AnalysisProvider.d.ts

@@ -0,0 +1,30 @@
+import type { DocumentJSON } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import type { Transaction } from 'dataply';
+/**
+ * Abstract base class for analysis providers.
+ * Subclasses should extend either RealtimeAnalysisProvider or IntervalAnalysisProvider.
+ */
+export declare abstract class AnalysisProvider<T extends DocumentJSON = DocumentJSON> {
+    protected api: DocumentDataplyAPI<T>;
+    /** Overflow row PK assigned by AnalysisManager during initialization. */
+    storageKey: number;
+    constructor(api: DocumentDataplyAPI<T>);
+    /**
+     * Unique name of this analysis type (e.g. 'ftsTermCount').
+     * Used as the key in the AnalysisHeader.
+     */
+    abstract readonly name: string;
+    /**
+     * Load existing statistics data from a raw string.
+     * Called during initialization to restore state from disk.
+     * @param raw The raw string from the overflow row, or null if no data exists yet
+     * @param tx Optional transaction
+     */
+    abstract load(raw: string | null, tx: Transaction): Promise<void>;
+    /**
+     * Serialize the current statistics data to a raw string for storage.
+     * @param tx Optional transaction
+     */
+    abstract serialize(tx: Transaction): Promise<string>;
+}

package/dist/types/core/DocumentFormatter.d.ts

@@ -1,10 +1,5 @@
 import type { DocumentJSON, FlattenedDocumentJSON } from '../types';
 export declare class DocumentFormatter<T extends DocumentJSON> {
     private flattenInternal;
-    /**
-     * returns flattened document
-     * @param document
-     * @returns
-     */
     flattenDocument(document: T): FlattenedDocumentJSON;
 }

package/dist/types/core/IntervalAnalysisProvider.d.ts

@@ -0,0 +1,31 @@
+import type { DocumentJSON, DataplyDocument } from '../types';
+import { AnalysisProvider } from './AnalysisProvider';
+import type { Transaction } from 'dataply';
+/**
+ * Sampling options for interval analysis providers.
+ * Specify either a ratio (0~1) or an exact count.
+ */
+export type SampleOptions = {
+    /** Ratio of documents to sample (0 exclusive ~ 1 inclusive) */
+    rate: number;
+    count?: never;
+} | {
+    rate?: never;
+    /** Exact number of documents to sample */
+    count: number;
+};
+/**
+ * Abstract base class for interval analysis providers.
+ * Data is accumulated in memory and persisted only when flush() is called.
+ * No mutation hooks — state is computed independently (e.g. on a schedule or at init).
+ */
+export declare abstract class IntervalAnalysisProvider<T extends DocumentJSON = DocumentJSON> extends AnalysisProvider<T> {
+    /**
+     * Sample random documents from the entire dataset.
+     * Fetches only PK index, then reads only the selected documents from disk.
+     * @param sampleOptions Sampling strategy — either `{ rate }` or `{ count }`
+     * @param tx Optional transaction
+     * @returns Randomly selected documents
+     */
+    sample(sampleOptions: SampleOptions, tx?: Transaction): Promise<DataplyDocument<T>[]>;
+}

package/dist/types/core/MetadataManager.d.ts

@@ -7,12 +7,5 @@ export declare class MetadataManager<T extends DocumentJSON> {
     getDocumentMetadata(tx: Transaction): Promise<DocumentDataplyMetadata>;
     getDocumentInnerMetadata(tx: Transaction): Promise<DocumentDataplyInnerMetadata>;
     updateDocumentInnerMetadata(metadata: DocumentDataplyInnerMetadata, tx: Transaction): Promise<void>;
-    /**
-     * 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
-     */
     migration(version: number, callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
 }

package/dist/types/core/MutationManager.d.ts

@@ -5,49 +5,10 @@ export declare class MutationManager<T extends DocumentJSON> {
     private api;
     constructor(api: DocumentDataplyAPI<T>);
     private insertDocumentInternal;
-    /**
-     * 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
-     */
     insertSingleDocument(document: T, tx?: Transaction): Promise<number>;
-    /**
-     * 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
-     */
     insertBatchDocuments(documents: T[], tx?: Transaction): Promise<number[]>;
-    /**
-     * Internal update method used by both fullUpdate and partialUpdate
-     * @param query The query to use
-     * @param computeUpdatedDoc Function that computes the updated document from the original
-     * @param tx The transaction to use
-     * @returns The number of updated documents
-     */
     private updateInternal;
-    /**
-     * 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
-     */
     fullUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: T | ((document: DataplyDocument<T>) => T), tx?: Transaction): Promise<number>;
-    /**
-     * 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
-     */
     partialUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: Partial<DataplyDocument<T>> | ((document: DataplyDocument<T>) => Partial<DataplyDocument<T>>), tx?: Transaction): Promise<number>;
-    /**
-     * 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
-     */
     deleteDocuments(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
 }

package/dist/types/core/Optimizer.d.ts

@@ -20,6 +20,7 @@ export declare class Optimizer<T extends Record<string, any>> {
     } | null;
     /**
      * FTS 타입 인덱스의 선택도를 평가합니다.
+     * FTSTermCount 통계가 있으면 토큰 빈도 기반 동적 score를 산출합니다.
      */
     evaluateFTSCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(indexName: string, config: any, query: Partial<DocumentDataplyQuery<V>>, queryFields: Set<string>, treeTx: BPTreeAsync<string | number, V>): {
         readonly tree: BPTreeAsync<string | number, V>;
@@ -28,7 +29,7 @@ export declare class Optimizer<T extends Record<string, any>> {
         readonly indexName: string;
         readonly isFtsMatch: true;
         readonly matchTokens: string[];
-        readonly score: 90;
+        readonly score: number;
         readonly compositeVerifyFields: readonly [];
         readonly coveredFields: readonly [any];
         readonly isIndexOrderSupported: false;

package/dist/types/core/QueryManager.d.ts

@@ -27,6 +27,7 @@ export declare class QueryManager<T extends DocumentJSON> {
             indexName: string;
             isFtsMatch: boolean;
             matchTokens?: string[];
+            coveredFields?: string[];
         }[];
         compositeVerifyConditions: {
             field: string;
@@ -58,6 +59,7 @@ export declare class QueryManager<T extends DocumentJSON> {
         indexName: string;
         isFtsMatch: boolean;
         matchTokens?: string[];
+        coveredFields?: string[];
     }[], tx: any): AsyncGenerator<DataplyDocument<T>>;
     /**
      * Count documents from the database that match the query

package/dist/types/core/RealtimeAnalysisProvider.d.ts

@@ -0,0 +1,27 @@
+import type { FlattenedDocumentJSON, DocumentJSON } from '../types';
+import { AnalysisProvider } from './AnalysisProvider';
+/**
+ * Abstract base class for realtime analysis providers.
+ * Mutation hooks (onInsert, onDelete, onUpdate) are called on every mutation
+ * and the result is persisted immediately.
+ */
+export declare abstract class RealtimeAnalysisProvider<T extends DocumentJSON = DocumentJSON> extends AnalysisProvider<T> {
+    /**
+     * Called when documents are inserted.
+     * @param documents The flattened documents that were inserted
+     */
+    abstract onInsert(documents: FlattenedDocumentJSON[]): Promise<void>;
+    /**
+     * Called when documents are deleted.
+     * @param documents The flattened documents that were deleted
+     */
+    abstract onDelete(documents: FlattenedDocumentJSON[]): Promise<void>;
+    /**
+     * Called when documents are updated.
+     * @param pairs Array of { oldDocument, newDocument } pairs
+     */
+    abstract onUpdate(pairs: {
+        oldDocument: FlattenedDocumentJSON;
+        newDocument: FlattenedDocumentJSON;
+    }[]): Promise<void>;
+}

package/dist/types/core/analysis/FTSTermCount.d.ts

@@ -0,0 +1,28 @@
+import type { DocumentJSON } from '../../types';
+import { Transaction } from 'dataply';
+import { IntervalAnalysisProvider } from '../IntervalAnalysisProvider';
+export declare class FTSTermCount<T extends DocumentJSON = DocumentJSON> extends IntervalAnalysisProvider<T> {
+    readonly name = "fts_term_count";
+    private termCount;
+    private sampleSize;
+    serialize(tx: Transaction): Promise<string>;
+    load(data: string | null, tx: Transaction): Promise<void>;
+    /**
+     * 특정 field/strategy/token의 문서 빈도를 반환합니다.
+     * 통계에 없으면 0을 반환합니다.
+     */
+    getTermCount(field: string, strategy: string, token: string): number;
+    /**
+     * 쿼리 토큰 배열에서 최소 빈도(AND 시맨틱스 상한선)를 반환합니다.
+     * 통계가 없거나 sampleSize가 0이면 -1을 반환합니다.
+     */
+    getMinTokenCount(field: string, strategy: string, tokens: string[]): number;
+    /**
+     * 통계가 유효한지 여부를 반환합니다.
+     */
+    get hasSampleData(): boolean;
+    /**
+     * 통계 수집 시 사용된 샘플 크기를 반환합니다.
+     */
+    getSampleSize(): number;
+}

package/dist/types/core/analysis/index.d.ts

@@ -0,0 +1,2 @@
+import { FTSTermCount } from './FTSTermCount';
+export declare const BuiltinAnalysisProviders: (typeof FTSTermCount)[];

package/dist/types/core/document.d.ts

@@ -52,6 +52,12 @@ export declare class DocumentDataply<T extends DocumentJSON> {
      * Initialize the document database
      */
     init(): Promise<void>;
+    /**
+     * Flush all interval analysis providers, forcing statistics to be recalculated.
+     * Call this after bulk inserts or periodically to keep FTS statistics fresh.
+     * @param tx Optional transaction
+     */
+    flushAnalysis(tx?: Transaction): Promise<void>;
     /**
      * Run a migration if the current schemeVersion is lower than the target version.
      * The callback is only executed when the database's schemeVersion is below the given version.

package/dist/types/core/documentAPI.d.ts

@@ -7,6 +7,7 @@ import { IndexManager } from './IndexManager';
 import { MutationManager } from './MutationManager';
 import { MetadataManager } from './MetadataManager';
 import { DocumentFormatter } from './DocumentFormatter';
+import { AnalysisManager } from './AnalysisManager';
 export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyAPI {
     runWithDefault: <T_1>(callback: (tx: Transaction) => Promise<T_1>, tx?: Transaction) => Promise<T_1>;
     runWithDefaultWrite: <T_1>(callback: (tx: Transaction) => Promise<T_1>, tx?: Transaction) => Promise<T_1>;
@@ -19,6 +20,7 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
     readonly mutationManager: MutationManager<T>;
     readonly metadataManager: MetadataManager<T>;
     readonly documentFormatter: DocumentFormatter<T>;
+    readonly analysisManager: AnalysisManager<T>;
     constructor(file: string, options: DocumentDataplyOptions);
     /**
      * Whether the document database has been initialized.
@@ -29,19 +31,48 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
     };
     get trees(): Map<string, import("dataply").BPTreeAsync<string | number, import("../types").DataplyTreeValue<import("../types").Primitive>>>;
     get indexedFields(): Set<string>;
+    /**
+     * Register an index.
+     * @param name The name of the index
+     * @param option The option of the index
+     * @param tx The transaction to use
+     */
     registerIndex(name: string, option: CreateIndexOption<T>, tx?: Transaction): Promise<void>;
     /**
      * Drop (remove) a named index.
+     * @param name The name of the index
+     * @param tx The transaction to use
      */
     dropIndex(name: string, tx?: Transaction): Promise<void>;
+    /**
+     * Get a document by its primary key.
+     * @param pk The primary key of the document
+     * @param tx The transaction to use
+     * @returns The document
+     */
     getDocument(pk: number, tx?: Transaction): Promise<DataplyDocument<T>>;
     /**
      * Backfill indices for newly created indices after data was inserted.
      * Delegated to IndexManager.
      */
     backfillIndices(tx?: Transaction): Promise<number>;
+    /**
+     * Flush all interval analysis providers, forcing statistics to be recalculated.
+     * Call this after bulk inserts or periodically to keep statistics fresh.
+     * @param tx The transaction to use
+     */
+    flushAnalysis(tx?: Transaction): Promise<void>;
     createDocumentInnerMetadata(indices: DocumentDataplyInnerMetadata['indices']): DocumentDataplyInnerMetadata;
+    /**
+     * Initialize the document database file.
+     * @param tx The transaction to use
+     */
     initializeDocumentFile(tx: Transaction): Promise<void>;
+    /**
+     * Verify the document database file.
+     * @param tx The transaction to use
+     * @returns True if the document database file is valid, false otherwise
+     */
     verifyDocumentFile(tx: Transaction): Promise<boolean>;
     /**
      * returns flattened document
@@ -49,8 +80,23 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
      * @returns
      */
     flattenDocument(document: T): FlattenedDocumentJSON;
+    /**
+     * Get the document metadata.
+     * @param tx The transaction to use
+     * @returns The document metadata
+     */
     getDocumentMetadata(tx: Transaction): Promise<DocumentDataplyMetadata>;
+    /**
+     * Get the document inner metadata.
+     * @param tx The transaction to use
+     * @returns The document inner metadata
+     */
     getDocumentInnerMetadata(tx: Transaction): Promise<DocumentDataplyInnerMetadata>;
+    /**
+     * Update the document inner metadata.
+     * @param metadata The document inner metadata
+     * @param tx The transaction to use
+     */
     updateDocumentInnerMetadata(metadata: DocumentDataplyInnerMetadata, tx: Transaction): Promise<void>;
     /**
      * Run a migration if the current schemeVersion is lower than the target version.

package/dist/types/types/index.d.ts

@@ -39,6 +39,14 @@ export interface DocumentDataplyInnerMetadata {
             IndexMetaConfig
         ];
     };
+    analysis?: number;
+}
+/**
+ * Analysis header row structure.
+ * Maps analysis type names to their overflow row PKs.
+ */
+export interface AnalysisHeader {
+    [type: string]: number;
 }
 export interface DocumentDataplyMetadata {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.10-alpha.4",
+  "version": "0.0.10-alpha.5",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",