bun-sqlite-for-rxdb 1.8.0 → 1.8.3-beta

package/dist/src/connection-pool.d.ts

@@ -1,4 +1,4 @@
 import { Database } from 'bun:sqlite';
 export declare function getDatabase(databaseName: string, filename: string): Database;
-export declare function releaseDatabase(databaseName: string): void;
+export declare function releaseDatabase(filename: string): void;
 //# sourceMappingURL=connection-pool.d.ts.map

package/dist/src/instance.d.ts

@@ -13,13 +13,16 @@ export declare class BunSQLiteStorageInstance<RxDocType> implements RxStorageIns
     readonly options: Readonly<BunSQLiteStorageSettings>;
     private primaryPath;
     private tableName;
+    private columnInfoCache;
     private useStoredColumns;
+    private filename;
     closed?: Promise<void>;
     constructor(params: RxStorageInstanceCreationParams<RxDocType, BunSQLiteStorageSettings>, settings?: BunSQLiteStorageSettings);
     private initTable;
     bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
     findDocumentsById(ids: string[], withDeleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
     query(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    private getBsonType;
     private sortDocuments;
     private getNestedValue;
     count(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;

package/dist/src/query/builder.d.ts

@@ -1,12 +1,23 @@
 import type { RxJsonSchema, MangoQuerySelector, RxDocumentData } from 'rxdb';
-import type { SqlFragment } from './operators';
-import type { SieveCache } from './sieve-cache';
-export { getCacheSize, clearCache } from './cache';
+import type { SqlFragment } from './sql-operators';
+import type { ColumnInfo } from './schema-to-field-type';
+import type { SieveCache } from '../utils/sieve-cache';
+import type { RegexCacheEntry } from './cache';
+export interface QueryContext<RxDocType> {
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>;
+    collectionName: string;
+    columnInfoCache: SieveCache<string, ColumnInfo>;
+    regexCache: SieveCache<string, RegexCacheEntry>;
+    indexCache: SieveCache<string, boolean>;
+    queryCache: SieveCache<string, SqlFragment | null>;
+}
+export declare function setStrictMode(enabled: boolean): void;
+export declare function getStrictMode(): boolean;
 export interface BipartiteQuery<RxDocType> {
     sqlWhere: SqlFragment | null;
     jsSelector: MangoQuerySelector<RxDocumentData<RxDocType>> | null;
 }
-export declare function buildWhereClause<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string, cache?: Map<string, SqlFragment | null> | SieveCache<string, SqlFragment | null>): SqlFragment | null;
-export declare function buildWhereClauseWithFallback<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string, cache?: Map<string, SqlFragment | null> | SieveCache<string, SqlFragment | null>): BipartiteQuery<RxDocType>;
-export declare function buildLogicalOperator<RxDocType>(operator: 'or' | 'nor' | 'and', conditions: MangoQuerySelector<RxDocumentData<RxDocType>>[], schema: RxJsonSchema<RxDocumentData<RxDocType>>, logicalDepth: number): SqlFragment | null;
+export declare function buildWhereClause<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, context: QueryContext<RxDocType>): SqlFragment | null;
+export declare function buildWhereClauseWithFallback<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, context: QueryContext<RxDocType>): BipartiteQuery<RxDocType>;
+export declare function buildLogicalOperator<RxDocType>(operator: 'or' | 'nor' | 'and', conditions: MangoQuerySelector<RxDocumentData<RxDocType>>[], context: QueryContext<RxDocType>, logicalDepth: number): SqlFragment | null;
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/query/cache.d.ts

@@ -1,18 +1,17 @@
 import type { Database } from 'bun:sqlite';
-import type { SqlFragment } from './operators';
-import { SieveCache } from './sieve-cache';
+import type { SqlFragment } from './sql-operators';
+import { SieveCache } from '../utils/sieve-cache';
+import type { ColumnInfo } from './schema-to-field-type';
 export declare const MAX_QUERY_CACHE_SIZE = 5000;
 export declare const MAX_REGEX_CACHE_SIZE = 100;
 export declare const MAX_INDEX_CACHE_SIZE = 1000;
+export declare const MAX_COLUMN_INFO_CACHE_SIZE = 200;
 export declare function getQueryCache(database: Database): SieveCache<string, SqlFragment | null>;
-export declare function getGlobalCache(): SieveCache<string, SqlFragment | null>;
-export declare function getCacheSize(): number;
-export declare function clearCache(): void;
 export interface RegexCacheEntry {
     regex: RegExp;
 }
-export declare function getRegexCache(): SieveCache<string, RegexCacheEntry>;
-export declare function clearRegexCache(): void;
-export declare function getIndexCache(): SieveCache<string, boolean>;
-export declare function clearIndexCache(): void;
+export declare function getRegexCache(database: Database): SieveCache<string, RegexCacheEntry>;
+export declare function getIndexCache(database: Database): SieveCache<string, boolean>;
+export declare function getJsRegexCache(database: Database): SieveCache<string, RegexCacheEntry>;
+export declare function getColumnInfoCache(database: Database): SieveCache<string, ColumnInfo>;
 //# sourceMappingURL=cache.d.ts.map

package/dist/src/query/js-operators/array.d.ts

@@ -0,0 +1,7 @@
+import type { MangoQuerySelector } from 'rxdb';
+import type { Database } from 'bun:sqlite';
+type MatcherFn<T = unknown> = (doc: T, selector: MangoQuerySelector<T>, database: Database) => boolean;
+type OperatorFn = (value: unknown, arg: unknown, matcher?: MatcherFn, database?: Database) => boolean;
+export declare const arrayOps: Record<string, OperatorFn>;
+export {};
+//# sourceMappingURL=array.d.ts.map

package/dist/src/query/js-operators/comparison.d.ts

@@ -0,0 +1,7 @@
+import type { MangoQuerySelector } from 'rxdb';
+import type { Database } from 'bun:sqlite';
+type MatcherFn<T = unknown> = (doc: T, selector: MangoQuerySelector<T>, database: Database) => boolean;
+type OperatorFn = (value: unknown, arg: unknown, matcher?: MatcherFn, database?: Database) => boolean;
+export declare const comparisonOps: Record<string, OperatorFn>;
+export {};
+//# sourceMappingURL=comparison.d.ts.map

package/dist/src/query/js-operators/evaluation.d.ts

@@ -0,0 +1,7 @@
+import type { MangoQuerySelector } from 'rxdb';
+import type { Database } from 'bun:sqlite';
+type MatcherFn<T = unknown> = (doc: T, selector: MangoQuerySelector<T>, database: Database) => boolean;
+type OperatorFn = (value: unknown, arg: unknown, matcher?: MatcherFn, database?: Database) => boolean;
+export declare const evaluationOps: Record<string, OperatorFn>;
+export {};
+//# sourceMappingURL=evaluation.d.ts.map

package/dist/src/query/js-operators/index.d.ts

@@ -0,0 +1,8 @@
+import type { RxDocumentData, MangoQuerySelector } from 'rxdb';
+import type { Database } from 'bun:sqlite';
+type MatcherFn<T = unknown> = (doc: T, selector: MangoQuerySelector<T>, database: Database) => boolean;
+export declare function isOperatorObject(obj: unknown): obj is Record<string, unknown>;
+export declare function matchesOperators(value: unknown, condition: Record<string, unknown>, matcher: MatcherFn, database: Database): boolean;
+export declare function matchesSelector<RxDocType>(doc: RxDocumentData<RxDocType>, selector: MangoQuerySelector<RxDocumentData<RxDocType>>, database: Database): boolean;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/query/js-regex-matcher.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from 'bun:sqlite';
+export declare function matchesRegex(value: unknown, pattern: string, options: string | undefined, database: Database): boolean;
+//# sourceMappingURL=js-regex-matcher.d.ts.map

package/dist/src/query/no-op-cache.d.ts

@@ -1,4 +1,4 @@
-import type { SqlFragment } from './operators';
+import type { SqlFragment } from './sql-operators';
 export declare class NoOpCache<K, V> {
     get size(): number;
     has(_key: K): boolean;

package/dist/src/query/operator-registry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Operator Registry - Single Source of Truth for MongoDB Query Operators
+ *
+ * Separates top-level operators (query structure) from field-level operators (value constraints).
+ * This separation prevents the "unsupported operator trap" where unknown operators are treated as field names.
+ *
+ * Architecture:
+ * - Top-level operators: Control query structure ($and, $or, $nor, $not)
+ * - Field-level operators: Apply constraints to field values ($eq, $gt, $regex, etc.)
+ *
+ * Design Principles:
+ * 1. Single Source of Truth: All supported operators defined in one place
+ * 2. Explicit Validation: Unknown operators return null → trigger Mingo fallback
+ * 3. Type Safety: Clear separation prevents mixing operator scopes
+ * 4. Maintainability: Adding new operators requires updating only this file
+ */
+/**
+ * Top-level operators that control query structure.
+ * These appear at the root of a query selector.
+ *
+ * Examples:
+ * - { $and: [{ age: 30 }, { active: true }] }
+ * - { $or: [{ name: 'Alice' }, { name: 'Bob' }] }
+ * - { $not: { age: { $gt: 25 } } }
+ */
+export declare const TOP_LEVEL_OPERATORS: Set<string>;
+/**
+ * Field-level operators that apply constraints to field values.
+ * These appear inside field expressions.
+ *
+ * Examples:
+ * - { age: { $gt: 25 } }
+ * - { name: { $regex: '^A' } }
+ * - { tags: { $elemMatch: { $eq: 'admin' } } }
+ */
+export declare const FIELD_LEVEL_OPERATORS: Set<string>;
+/**
+ * Checks if a key is a supported top-level operator.
+ *
+ * @param key - The key to check (e.g., '$and', '$text', 'age')
+ * @returns true if the key is a supported top-level operator
+ *
+ * @example
+ * isTopLevelOperator('$and')  // true
+ * isTopLevelOperator('$text') // false (unsupported)
+ * isTopLevelOperator('age')   // false (field name)
+ */
+export declare function isTopLevelOperator(key: string): boolean;
+/**
+ * Checks if a key is a supported field-level operator.
+ *
+ * @param key - The key to check (e.g., '$eq', '$bitsAllSet', 'name')
+ * @returns true if the key is a supported field-level operator
+ *
+ * @example
+ * isFieldLevelOperator('$eq')         // true
+ * isFieldLevelOperator('$bitsAllSet') // false (unsupported)
+ * isFieldLevelOperator('name')        // false (field name)
+ */
+export declare function isFieldLevelOperator(key: string): boolean;
+//# sourceMappingURL=operator-registry.d.ts.map

package/dist/src/query/regex-to-sql.d.ts

@@ -0,0 +1,8 @@
+import type { QueryContext } from './builder';
+export interface SqlFragment {
+    sql: string;
+    args: (string | number | boolean)[];
+}
+export declare function extractRegexPrefix(pattern: string): string | null;
+export declare function smartRegexToLike<RxDocType>(field: string, pattern: string, options: string | undefined, context: QueryContext<RxDocType>, fieldName: string): SqlFragment | null;
+//# sourceMappingURL=regex-to-sql.d.ts.map

package/dist/src/query/schema-to-field-type.d.ts

@@ -0,0 +1,9 @@
+import type { RxJsonSchema, RxDocumentData } from 'rxdb';
+export interface ColumnInfo {
+    column?: string;
+    jsonPath?: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'unknown';
+    elementType?: 'string' | 'number' | 'boolean' | 'object';
+}
+export declare function getColumnInfo<RxDocType>(path: string, schema: RxJsonSchema<RxDocumentData<RxDocType>>): ColumnInfo;
+//# sourceMappingURL=schema-to-field-type.d.ts.map

package/dist/src/query/sql-operators/array.d.ts

@@ -0,0 +1,7 @@
+import type { SqlFragment } from './primitives';
+import type { SqlResult } from './result';
+import type { ColumnInfo } from '../schema-to-field-type';
+export declare function translateIn(field: string, values: unknown[], columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateNin(field: string, values: unknown[], columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateSize(jsonColumn: string, jsonPath: string, size: number, isDirectPath?: boolean, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+//# sourceMappingURL=array.d.ts.map

package/dist/src/query/sql-operators/comparison.d.ts

@@ -0,0 +1,10 @@
+import type { SqlFragment } from './primitives';
+import type { SqlResult } from './result';
+import type { ColumnInfo } from '../schema-to-field-type';
+export declare function translateEq(field: string, value: unknown, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateNe(field: string, value: unknown, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateGt(field: string, value: unknown, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateGte(field: string, value: unknown, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateLt(field: string, value: unknown, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+export declare function translateLte(field: string, value: unknown, columnInfo?: ColumnInfo): SqlResult<SqlFragment>;
+//# sourceMappingURL=comparison.d.ts.map

package/dist/src/query/sql-operators/evaluation.d.ts

@@ -0,0 +1,8 @@
+import type { SqlFragment } from './primitives';
+import type { SqlResult } from './result';
+import type { QueryContext } from '../builder';
+export declare function translateExists(field: string, exists: boolean): SqlResult<SqlFragment>;
+export declare function translateRegex<RxDocType>(field: string, pattern: string, options: string | undefined, context: QueryContext<RxDocType>, fieldName: string): SqlResult<SqlFragment>;
+export declare function translateType<RxDocType>(jsonColumn: string, fieldName: string, type: string | number, isDirectPath?: boolean, context?: QueryContext<RxDocType>): SqlResult<SqlFragment>;
+export declare function translateMod(field: string, value: unknown): SqlResult<SqlFragment>;
+//# sourceMappingURL=evaluation.d.ts.map

package/dist/src/query/sql-operators/field-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getTypeExpression(field: string): string;
+//# sourceMappingURL=field-utils.d.ts.map

package/dist/src/query/sql-operators/index.d.ts

@@ -0,0 +1,16 @@
+import type { SqlFragment, PathSegment } from './primitives';
+import { parsePath, buildJsonPath, normalizeValueForSQLite } from './primitives';
+import { translateEq, translateNe, translateGt, translateGte, translateLt, translateLte } from './comparison';
+import { translateIn, translateNin, translateSize } from './array';
+import { translateExists, translateRegex, translateType, translateMod } from './evaluation';
+import { translateElemMatch, wrapWithArrayTraversal, wrapWithNot, resetQueryBudget, type ElemMatchCriteria } from './traversal';
+import type { QueryContext } from '../builder';
+export { SqlFragment, PathSegment, ElemMatchCriteria };
+export { parsePath, buildJsonPath, normalizeValueForSQLite };
+export { translateEq, translateNe, translateGt, translateGte, translateLt, translateLte };
+export { translateIn, translateNin, translateSize };
+export { translateExists, translateRegex, translateType, translateMod };
+export { translateElemMatch, wrapWithArrayTraversal, wrapWithNot, resetQueryBudget };
+export type { SqlResult } from './result';
+export declare function translateLeafOperator<RxDocType>(op: string, field: string, value: unknown, context: QueryContext<RxDocType>, actualFieldName: string): SqlFragment | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/query/sql-operators/null-aware.d.ts

@@ -0,0 +1,4 @@
+import type { SqlFragment } from './primitives';
+import type { SqlResult } from './result';
+export declare function buildNullAwareInClause(field: string, values: unknown[], operator: 'IN' | 'NOT IN'): SqlResult<SqlFragment>;
+//# sourceMappingURL=null-aware.d.ts.map

package/dist/src/query/sql-operators/null-semantics.d.ts

@@ -0,0 +1,2 @@
+export declare function shouldUseFieldLevelNull(op: string, value: unknown): boolean;
+//# sourceMappingURL=null-semantics.d.ts.map

package/dist/src/query/sql-operators/primitives.d.ts

@@ -0,0 +1,17 @@
+import type { RxJsonSchema } from 'rxdb';
+export interface SqlFragment {
+    sql: string;
+    args: (string | number | boolean | bigint | null)[];
+}
+export type PathSegment = {
+    type: 'property';
+    key: string;
+} | {
+    type: 'index';
+    index: number;
+};
+export declare function parsePath(fieldName: string, schema?: RxJsonSchema<any>): PathSegment[];
+export declare function buildJsonPath(fieldName: string, schema?: RxJsonSchema<any>): string;
+export declare function normalizeValueForSQLite(value: unknown): string | number | boolean | bigint | null;
+export declare function isArrayOrObject(value: unknown): boolean;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/src/query/sql-operators/query-budget.d.ts

@@ -0,0 +1,4 @@
+export declare function resetQueryBudget(): void;
+export declare function canAllocateVirtualTable(): boolean;
+export declare function allocateVirtualTable(): boolean;
+//# sourceMappingURL=query-budget.d.ts.map

package/dist/src/query/sql-operators/result.d.ts

@@ -0,0 +1,34 @@
+export type SqlResult<T = SqlFragment> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    reason: string;
+    location: string;
+    context?: unknown;
+} | {
+    ok: false;
+    fallback: true;
+    reason: string;
+    context?: unknown;
+};
+export interface SqlFragment {
+    sql: string;
+    args: (string | number | boolean | bigint | null)[];
+}
+export declare function ok<T>(value: T): SqlResult<T>;
+export declare function fail(reason: string, location: string, context?: unknown): SqlResult<never>;
+export declare function jsFallback(reason: string, context?: unknown): SqlResult<never>;
+export declare function isOk<T>(result: SqlResult<T>): result is {
+    ok: true;
+    value: T;
+};
+export declare function isJsFallback(result: SqlResult<unknown>): result is {
+    ok: false;
+    fallback: true;
+    reason: string;
+    context?: unknown;
+};
+export declare function unwrap<T>(result: SqlResult<T>): T | null;
+export declare function getError(result: SqlResult<unknown>): string | null;
+//# sourceMappingURL=result.d.ts.map

package/dist/src/query/sql-operators/traversal.d.ts

@@ -0,0 +1,13 @@
+import type { SqlFragment } from './primitives';
+import { resetQueryBudget } from './query-budget';
+import type { SqlResult } from './result';
+import type { QueryContext } from '../builder';
+import { type SchemaType } from '../sql-typeguard';
+export { resetQueryBudget };
+export declare function getElementFragment(op: string, value: unknown, elementType?: SchemaType): SqlResult<SqlFragment>;
+export declare function buildElemMatchConditions<RxDocType>(criteria: Record<string, unknown>, context: QueryContext<RxDocType>, baseFieldName: string): SqlResult<SqlFragment>;
+export type ElemMatchCriteria = string | number | boolean | null | Record<string, unknown>;
+export declare function translateElemMatch<RxDocType>(field: string, criteria: ElemMatchCriteria, context: QueryContext<RxDocType>, actualFieldName: string): SqlResult<SqlFragment>;
+export declare function wrapWithArrayTraversal(elementFragment: SqlFragment, jsonPath: string, op: string, depth?: number, recursive?: boolean): SqlResult<SqlFragment>;
+export declare function wrapWithNot(innerFragment: SqlFragment): SqlResult<SqlFragment>;
+//# sourceMappingURL=traversal.d.ts.map

package/dist/src/query/sql-typeguard.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type compatibility checker for MongoDB-like query operators.
+ * Determines when type guards are needed for SQL translation.
+ */
+import type { SqlFragment } from './sql-operators/primitives';
+export type SchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'unknown';
+export interface ColumnInfo {
+    type: SchemaType;
+    isArray?: boolean;
+}
+export declare class TypeChecker {
+    /**
+     * Check if schema type is compatible with value type.
+     * MongoDB has NO type coercion: "25" !== 25
+     */
+    static isCompatible(schemaType: SchemaType, valueType: SchemaType): boolean;
+    /**
+     * Early rejection for type mismatches on known fields.
+     * MongoDB semantics: type mismatch = no matches (or all matches for $ne).
+     *
+     * Returns SqlFragment if type mismatch detected, null otherwise.
+     */
+    static earlyRejectTypeMismatch(columnInfo: ColumnInfo | undefined, value: unknown, op: string): SqlFragment | null;
+    /**
+     * Determine if a type guard is needed for SQL comparison.
+     * Returns true when types don't match or schema info is missing.
+     */
+    static needsGuard(columnInfo: ColumnInfo | undefined, value: unknown): boolean;
+    /**
+     * Check if value type matches expected schema type.
+     * Used for validation and error messages.
+     */
+    static matchesSchema(columnInfo: ColumnInfo | undefined, value: unknown): boolean;
+}
+//# sourceMappingURL=sql-typeguard.d.ts.map

package/dist/src/query/type-guards.d.ts

@@ -0,0 +1,2 @@
+export declare function addTypeGuard(field: string, value: unknown, comparisonSql: string): string;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/src/query/value-from-unknowntype.d.ts

@@ -0,0 +1,21 @@
+import type { RxJsonSchema } from 'rxdb';
+import type { SqlFragment } from './sql-operators';
+/**
+ * Handles queries on fields with unknown types (not in schema).
+ *
+ * Strategy: Use JavaScript matcher instead of SQL.
+ * Reason: Benchmarks show JS is 2-9x faster than SQLite json_each() for unknown types.
+ *
+ * This module provides the core logic for traversing nested paths with implicit array handling.
+ */
+/**
+ * Get nested value from object, with implicit array traversal.
+ *
+ * Examples:
+ * - getNestedValue({a: {b: 1}}, 'a.b') → 1
+ * - getNestedValue({a: [{b: 1}, {b: 2}]}, 'a.b') → [1, 2]
+ * - getNestedValue({a: [[{b: 1}]]}, 'a.b') → [1]
+ */
+export declare function getNestedValue(obj: unknown, path: string): unknown;
+export declare function buildUnknownTypeQuery(fieldPath: string, scalarFragment: SqlFragment, arrayFragment: SqlFragment, schema: RxJsonSchema<any>): SqlFragment | null;
+//# sourceMappingURL=value-from-unknowntype.d.ts.map

package/dist/src/statement-manager.d.ts

@@ -6,12 +6,11 @@ export type QueryWithParams = {
 export declare class StatementManager {
     private db;
     private staticStatements;
-    private static readonly MAX_STATEMENTS;
     private closed;
     constructor(db: Database);
     private checkClosed;
-    private evictOldest;
     all<T = unknown>(queryWithParams: QueryWithParams): T[];
+    values<T = unknown[]>(queryWithParams: QueryWithParams): T[];
     get(queryWithParams: QueryWithParams): unknown;
     run(queryWithParams: QueryWithParams): Changes;
     close(): void;

package/dist/src/telemetry.d.ts

@@ -0,0 +1,7 @@
+export interface QueryTelemetry {
+    sqlFallbackCount: number;
+    sqlSuccessCount: number;
+    jsEvaluationCount: number;
+}
+export declare function logSqlFallback(selector: unknown, reason: string): void;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/src/top-k-heap.d.ts

@@ -0,0 +1,13 @@
+import type { RxDocumentData, MangoQuerySortPart } from 'rxdb';
+export declare class TopKHeap<RxDocType> {
+    private heap;
+    private maxSize;
+    private compareFn;
+    constructor(maxSize: number, sort: MangoQuerySortPart<RxDocType>[], getBsonType: (val: any) => number, getNestedValue: (obj: RxDocumentData<RxDocType>, path: string) => unknown);
+    insert(doc: RxDocumentData<RxDocType>): void;
+    private bubbleUp;
+    private bubbleDown;
+    getSorted(): RxDocumentData<RxDocType>[];
+    size(): number;
+}
+//# sourceMappingURL=top-k-heap.d.ts.map

package/dist/src/types.d.ts

@@ -22,6 +22,13 @@ export interface BunSQLiteStorageSettings {
      * @experimental Alpha feature - opt-in for testing
      */
     useStoredColumns?: false | 'virtual' | 'stored';
+    /**
+     * Enable strict MongoDB/Mingo type checking behavior.
+     * - false (default): RxDB-friendly mode - Date queries match ISO string fields with GLOB validation
+     * - true: Strict mode - Date queries only match Date fields (MongoDB/Mingo spec compliance)
+     * @default false
+     */
+    strict?: boolean;
 }
 export interface BunSQLiteInternals {
     db: Database;

package/dist/src/utils/sieve-cache.d.ts

@@ -0,0 +1,26 @@
+export declare class SieveCache<K, V> {
+    #private;
+    constructor(capacity: number);
+    get size(): number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callbackfn: (value: V, key: K, map: SieveCache<K, V>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    getStats(): {
+        hits: number;
+        misses: number;
+        total: number;
+        hitRate: number;
+        size: number;
+        capacity: number;
+    };
+    resetStats(): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=sieve-cache.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-sqlite-for-rxdb",
-  "version": "1.8.0",
+  "version": "1.8.3-beta",
   "author": "adam2am",
   "repository": {
     "type": "git",