arrowbase 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1802 @@
+import { C as Collection, S as SyncConfig, I as InsertMutationFn, U as UpdateMutationFn, D as DeleteMutationFn, R as RowValue, b as IndexConstructor, c as CreateCollectionConfig, d as CreateOptimisticActionsOptions, T as Transaction, P as PacedMutationsConfig, e as DebounceStrategyOptions, f as DebounceStrategy, Q as QueueStrategyOptions, g as QueueStrategy, h as ThrottleStrategyOptions, i as ThrottleStrategy, L as LocalOnlyCollectionConfig, j as LocalOnlyCollectionOptionsResult, k as LocalStorageCollectionConfig, l as LocalStorageCollectionOptionsResult, m as QueryIR, n as Select, B as BasicExpression$1, A as Aggregate, o as IncludesSubquery, W as Where, H as Having, G as GroupBy, O as OrderBy, p as RootRefProxy, q as SingleRowRefProxy, r as ToArrayWrapper, s as ConcatToArrayWrapper, M as MaterializeWrapper, t as CompareOptions, u as PropRef, v as IncludesMaterialization, w as LoadSubsetOptions, x as UtilsRecord, y as StringCollationConfig, z as ChangeMessage, E as SubscribeChangesOptions, F as CollectionSubscription, J as BaseIndex, K as IndexOperation, N as RangeQueryOptions, V as IndexInterface, X as OrderByDirection, Y as IndexStats, Z as CollectionStatus, _ as BBox, $ as Point, a0 as OperatorName, a as CompiledSchema, a1 as ColumnTypeName } from './collection-DGlKgOGi.js';
+export { a2 as BaseStrategy, a3 as BatchStrategy, a4 as BatchStrategyOptions, a5 as ChangeEmitter, a6 as ChangeEvent, a7 as ChangeListener, a8 as ChangeMessageOrDeleteKeyMessage, a9 as ChangeOp, aa as ClearStorageFn, ab as CollectionEvents, ac as CollectionMutationFnParams, ad as CollectionOptions, ae as CollectionRef, af as CollectionStatusChangeEvent, ag as CollectionSubscribersChangeEvent, ah as CollectionTruncateEvent, ai as ColumnDef, aj as ColumnTypeCode, ak as CompiledColumn, al as CurrentStateAsChangesOptions, am as Deferred, an as DeleteKeyMessage, ao as DeleteMutationFnParams, ap as Dictionary, aq as Fn, ar as From, as as Func, at as GetStorageSizeFn, au as INCLUDES_SCALAR_FIELD, av as IR, aw as IndexOptions, ax as InsertConfig, ay as InsertMutationFnParams, az as Join, aA as JoinClause, aB as Limit, aC as LineString, aD as LoadSubsetFn, aE as LocalOnlyCollectionUtils, aF as LocalStorageCollectionUtils, aG as MutationFn, aH as MutationFnParams, aI as NamespacedRow, aJ as NonEmptyArray, aK as Offset, aL as OperationConfig, aM as OperationType, aN as OptimisticChangeMessage, aO as OrderByClause, aP as Parser, aQ as PendingMutation, aR as Polygon, aS as QueryRef, aT as Ref, aU as RefLeaf, aV as RefProxy, aW as ResolveTransactionChanges, aX as SchemaInput, aY as StorageApi, aZ as StorageEventApi, a_ as Strategy, a$ as StrategyOptions, b0 as Transaction, b1 as TransactionCollectionLike, b2 as TransactionConfig, b3 as TransactionState, b4 as TransactionWithMutations, b5 as UnloadSubsetFn, b6 as UpdateMutationFnParams, b7 as Value, b8 as ValueOf, b9 as ValuesHeap, ba as VirtualPropsRefProxy, bb as add, bc as and, bd as avg, be as byteWidthOf, bf as caseWhen, bg as coalesce, bh as comparisonFunctions, bi as concat, bj as count, bk as createRefProxy, bl as createRefProxyWithSelected, bm as createResidualWhere, bn as createSingleRowRefProxy, bo as createTransaction, bp as defineSchema, bq as divide, br as eq, bs as followRef, bt as getActiveTransaction, bu as getHavingExpression, bv as getWhereExpression, bw as gt, bx as gte, by as ilike, bz as inArray, bA as isDictionary, bB as isExpressionLike, bC as isNull, bD as isRefProxy, bE as isResidualWhere, bF as isUndefined, bG as isVariableWidth, bH as length, bI as like, bJ as lower, bK as lt, bL as lte, bM as materialize, bN as max, bO as min, bP as multiply, bQ as not, bR as operators, bS as or, bT as subtract, bU as sum, bV as toArray, bW as toExpression, bX as upper, bY as val } from './collection-DGlKgOGi.js';
+import { Q as Query$1, P as Predicate$1, O as OrderSpec, S as SortDir } from './query-CzV9E57Y.js';
+export { C as ColumnRef, F as FilterExpr, a as FilterScalar, I as InNode, b as QueryExecutor, c as QuerySnapshot, d as StringOp, e as StringOpNode, f as StringOpOptions, g as f, h as fAnd, i as fContains, j as fEndsWith, k as fEq, l as fGt, m as fGte, n as fInArray, o as fIsNotNull, p as fIsNull, q as fLike, r as fLt, s as fLte, t as fMatches, u as fNeq, v as fNot, w as fOr, x as fStartsWith, y as query, z as run } from './query-CzV9E57Y.js';
+import { D as Delta, S as SyncAdapter } from './types-CSoU6uED.js';
+export { a as DeltaOp } from './types-CSoU6uED.js';
+import { IR } from '@tanstack/db';
+
+/**
+ * Layer-E metadata attached to Collections created through createCollection().
+ * Kept separate from createCollection.ts so collection mutation wiring can read
+ * handlers without creating a circular import.
+ */
+interface CollectionMetadata {
+    sync?: SyncConfig;
+    onInsert?: InsertMutationFn;
+    onUpdate?: UpdateMutationFn;
+    onDelete?: DeleteMutationFn;
+    getKey?: (item: RowValue) => number | string;
+    gcTime?: number;
+    startSync?: boolean;
+    syncMode?: 'eager' | 'on-demand';
+    autoIndex?: 'off' | 'eager';
+    defaultIndexType?: IndexConstructor;
+}
+declare function getCollectionMetadata(collection: Collection): Readonly<CollectionMetadata> | undefined;
+
+/**
+ * `createCollection` — `@tanstack/db`-compatible top-level factory.
+ *
+ * Mirrors the shape of `@tanstack/db`'s `createCollection(options)`
+ * but adapts it to ArrowBase's columnar store:
+ *
+ *   - `schema` must be a `CompiledSchema` (Layer C will accept
+ *     `StandardSchemaV1` and auto-compile).
+ *   - `capacity` is required (ArrowBase is fixed-capacity).
+ *   - `sync` / `onInsert` / `onUpdate` / `onDelete` are stored on the
+ *     Collection as "Layer-E metadata"; Layer E wires them into the
+ *     transaction flow. Accepting + storing them now keeps the API
+ *     drop-in-swap-capable even before the behavior lands.
+ *
+ * Returns a `Collection` instance — same class as `Collection.create`.
+ *
+ * This is the Layer-B public entry point for ArrowBase users who want
+ * to write their import as `import { createCollection } from 'arrowbase'`
+ * and have it behave just like the TanStack DB import.
+ */
+
+/**
+ * Construct a new Collection from a TanStack-DB-shaped config.
+ *
+ * @example
+ * ```ts
+ * import { compileSchema, defineSchema, createCollection } from 'arrowbase';
+ *
+ * const schema = compileSchema(defineSchema({
+ *   name: 'todos',
+ *   columns: {
+ *     __id: { type: 'uint32' },
+ *     title: { type: 'utf8' },
+ *     done:  { type: 'bool' },
+ *   },
+ * }));
+ *
+ * const todos = createCollection({
+ *   schema,
+ *   capacity: 10_000,
+ *   id: 'todos',
+ *   getKey: (t) => t.__id as number,
+ * });
+ * ```
+ */
+declare function createCollection<T extends object = RowValue, TKey extends string | number = number>(config: CreateCollectionConfig<T, TKey>): Collection;
+
+/**
+ * Creates an optimistic action that opens a transaction per call.
+ *
+ * `onMutate` runs synchronously inside the transaction's ambient scope so
+ * collection writes are captured optimistically. `mutationFn` receives the same
+ * variables during commit.
+ */
+declare function createOptimisticAction<TVariables = unknown, T extends object = Record<string, unknown>>(options: CreateOptimisticActionsOptions<TVariables, T>): (variables: TVariables) => Transaction<T>;
+
+/**
+ * Creates a paced mutation helper with pluggable timing strategy.
+ *
+ * Optimistic writes run immediately inside an ambient transaction. Non-queue
+ * strategies coalesce calls into one pending transaction until the strategy
+ * invokes its callback. Queue strategies capture one transaction per call.
+ */
+declare function createPacedMutations<TVariables = unknown, T extends object = Record<string, unknown>>(config: PacedMutationsConfig<TVariables, T>): (variables: TVariables) => Transaction<T>;
+
+declare function debounceStrategy(options: DebounceStrategyOptions): DebounceStrategy;
+declare function throttleStrategy(options: ThrottleStrategyOptions): ThrottleStrategy;
+declare function queueStrategy(options?: QueueStrategyOptions): QueueStrategy;
+
+declare function localOnlyCollectionOptions<T extends object = Record<string, unknown>, TKey extends string | number = string | number>(config: LocalOnlyCollectionConfig<T, TKey>): LocalOnlyCollectionOptionsResult<T, TKey>;
+
+declare function localStorageCollectionOptions<T extends object = Record<string, unknown>, TKey extends string | number = string | number>(config: LocalStorageCollectionConfig<T, TKey>): LocalStorageCollectionOptionsResult<T, TKey>;
+
+/**
+ * Maps a uint32 primary key to its dense row index. Phase 1 uses a JS Map;
+ * a SAB-resident open-addressed hash map is planned for cross-worker
+ * visibility in a later phase.
+ *
+ * `TOMBSTONE` (0xffffffff) is reserved as a sentinel for "no row".
+ */
+declare const TOMBSTONE_ROW = 4294967295;
+declare class RowIndex {
+    private map;
+    get size(): number;
+    /** Return the row index for `id`, or undefined if absent. */
+    lookup(id: number): number | undefined;
+    /** Same as lookup but throws if absent. */
+    require(id: number): number;
+    /** Insert `id → row`. Returns false if `id` already existed. */
+    insert(id: number, row: number): boolean;
+    /** Remove mapping for `id`. Returns the previous row index, or undefined. */
+    remove(id: number): number | undefined;
+    /** Iterate `[id, row]` pairs. */
+    entries(): IterableIterator<[number, number]>;
+    /** Remove every mapping. */
+    clear(): void;
+}
+
+type UndoOp = 'insert' | 'update' | 'delete';
+/**
+ * A single reversible mutation. Stored in the undo ring so rollback can
+ * replay it in reverse.
+ *
+ * For v1 we keep the payload as plain JS objects (column name → prior JS
+ * value). Memory cost is O(touched columns) per mutation. A later phase may
+ * pack the payload into a per-row binary diff.
+ */
+interface UndoRecord {
+    /** Monotonic id assigned by the ring; also the generation for rollback markers. */
+    readonly seq: number;
+    readonly op: UndoOp;
+    readonly rowId: number;
+    /** Row slot that was used. */
+    readonly row: number;
+    /** Previous values, keyed by column name. Empty for `insert`. */
+    readonly prev: Readonly<Record<string, unknown>>;
+    /** Full row snapshot for `delete` so re-insert can restore it. */
+    readonly snapshot?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Fixed-capacity circular buffer of UndoRecords.
+ *
+ * When the ring wraps, the oldest entries are silently overwritten. Rollback
+ * to a `mark()` that has been overwritten throws `UndoError` so callers know
+ * the rollback is no longer possible.
+ */
+declare class UndoRing {
+    readonly capacity: number;
+    private records;
+    private head;
+    private count;
+    private seqCounter;
+    constructor(capacity: number);
+    get size(): number;
+    /** Next seq that will be assigned. */
+    get nextSeq(): number;
+    /** Push a new record; returns its seq. */
+    push(op: UndoOp, rowId: number, row: number, prev: Record<string, unknown>, snapshot?: Record<string, unknown>): number;
+    /** Oldest valid seq currently in the ring, or -1 if empty. */
+    oldestSeq(): number;
+    /** Return a stable mark for the next seq to be written. */
+    mark(): number;
+    /**
+     * Drain records pushed at or after `mark`, newest-first. Used by `rollback`.
+     * Throws if `mark` has been overwritten by ring wrap.
+     */
+    drainSince(mark: number): UndoRecord[];
+    private oldestSeqOrZero;
+    /** Clear the ring without resetting seqCounter. */
+    clear(): void;
+}
+
+/**
+ * Query builder — `@tanstack/db` parity (Layer C.4).
+ *
+ * This module ports the non-incremental builder surface from
+ * `@tanstack/db@0.6.16`: a chainable `BaseQueryBuilder` that emits
+ * the QueryIR defined in `ir.ts`. Compiler/runtime execution lands in
+ * later Layer-C tasks; this file only builds validated IR.
+ */
+
+type ContextSchema = Record<string, unknown>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type JoinType$1 = 'left' | 'right' | 'inner' | 'outer' | 'full' | 'cross';
+interface Context {
+    baseSchema: ContextSchema;
+    schema: ContextSchema;
+    fromSourceName?: string;
+    hasJoins?: boolean;
+    joinTypes?: Record<string, JoinType$1>;
+    result?: unknown;
+    hasResult?: boolean;
+    singleResult?: boolean;
+}
+type EmptyContext = {
+    baseSchema: {};
+    schema: {};
+    hasJoins: false;
+    hasResult: false;
+};
+type QuerySource = Collection | BaseQueryBuilder<any>;
+type SourceRecord = Record<string, QuerySource>;
+type Source = SourceRecord;
+type InferCollectionType<T> = T extends Collection ? Record<string, unknown> : never;
+type GetResult<TContext extends Context> = TContext extends {
+    hasResult: true;
+    result: infer TResult;
+} ? TResult : TContext extends {
+    hasJoins: true;
+    schema: infer TSchema;
+} ? TSchema : TContext extends {
+    schema: infer TSchema;
+    fromSourceName: infer TAlias;
+} ? TAlias extends keyof TSchema ? TSchema[TAlias] : TSchema : unknown;
+type InferResultType<TContext extends Context> = TContext extends {
+    singleResult: true;
+} ? GetResult<TContext> | undefined : Array<GetResult<TContext>>;
+type ExtractContext<T> = T extends {
+    readonly __context: infer TContext;
+} ? TContext extends Context ? TContext : never : never;
+type QueryResult<T> = T extends {
+    readonly __context: infer TContext;
+} ? TContext extends Context ? GetResult<TContext> : never : never;
+type SchemaFromSource<T extends SourceRecord> = Prettify<{
+    [K in keyof T & string]: T[K] extends BaseQueryBuilder<infer TContext> ? GetResult<TContext> : T[K] extends Collection ? InferCollectionType<T[K]> : Record<string, unknown>;
+}>;
+type ApplyJoinOptionalityToMergedSchema<TExistingSchema extends ContextSchema, TNewSchema extends ContextSchema, TJoinType extends JoinType$1, TFromSourceName extends string> = Prettify<{
+    [K in keyof TExistingSchema]: K extends TFromSourceName ? TJoinType extends 'right' | 'full' ? TExistingSchema[K] | undefined : TExistingSchema[K] : TExistingSchema[K];
+} & {
+    [K in keyof TNewSchema]: TJoinType extends 'left' | 'full' ? TNewSchema[K] | undefined : TNewSchema[K];
+}>;
+type PreserveResultFlags<TContext extends Context> = (TContext extends {
+    result: infer TResult;
+    hasResult: true;
+} ? {
+    result: TResult;
+    hasResult: true;
+} : {}) & (TContext extends {
+    singleResult: true;
+} ? {
+    singleResult: true;
+} : {});
+type MergeContextForJoinCallback<TContext extends Context, TNewSchema extends ContextSchema> = Prettify<{
+    baseSchema: TContext['baseSchema'];
+    schema: Prettify<TContext['schema'] & TNewSchema>;
+    fromSourceName: TContext['fromSourceName'] & string;
+    hasJoins: true;
+} & PreserveResultFlags<TContext>>;
+type MergeContextWithJoinType<TContext extends Context, TNewSchema extends ContextSchema, TJoinType extends JoinType$1> = Prettify<{
+    baseSchema: TContext['baseSchema'];
+    schema: ApplyJoinOptionalityToMergedSchema<TContext['schema'], TNewSchema, TJoinType, TContext['fromSourceName'] & string>;
+    fromSourceName: TContext['fromSourceName'] & string;
+    hasJoins: true;
+    joinTypes: (TContext['joinTypes'] extends Record<string, JoinType$1> ? TContext['joinTypes'] : {}) & {
+        [K in keyof TNewSchema & string]: TJoinType;
+    };
+} & PreserveResultFlags<TContext>>;
+type ResultTypeFromSelectValue<TValue> = TValue extends BasicExpression$1<infer TResult> ? TResult : TValue extends Aggregate<infer TResult> ? TResult : TValue extends ToArrayWrapper<infer TResult> ? Array<TResult> : TValue extends ConcatToArrayWrapper<any> ? string : TValue extends MaterializeWrapper<infer TResult, infer TSingle> ? TSingle extends true ? TResult | undefined : Array<TResult> : TValue extends BaseQueryBuilder<any> ? Array<QueryResult<TValue>> : TValue;
+type ResultTypeFromSelect<TSelect> = TSelect extends BasicExpression$1<any> | Aggregate<any> | ToArrayWrapper<any> | ConcatToArrayWrapper<any> | MaterializeWrapper<any, any> | BaseQueryBuilder<any> ? ResultTypeFromSelectValue<TSelect> : TSelect extends Record<string, unknown> ? {
+    [K in keyof TSelect]: ResultTypeFromSelect<TSelect[K]>;
+} : ResultTypeFromSelectValue<TSelect>;
+type WithResult<TContext extends Context, TResult> = {
+    baseSchema: TContext['baseSchema'];
+    schema: TContext['schema'];
+    result: TResult;
+    hasResult: true;
+} & (TContext extends {
+    fromSourceName: infer TAlias;
+} ? {
+    fromSourceName: TAlias & string;
+} : {}) & (TContext extends {
+    hasJoins: infer THasJoins;
+} ? {
+    hasJoins: THasJoins & boolean;
+} : {}) & (TContext extends {
+    joinTypes: infer TJoinTypes;
+} ? {
+    joinTypes: TJoinTypes & Record<string, JoinType$1>;
+} : {}) & (TContext extends {
+    singleResult: infer TSingle;
+} ? {
+    singleResult: TSingle & boolean;
+} : {});
+type InitialQueryBuilder = Pick<BaseQueryBuilder<EmptyContext>, 'from'>;
+type QueryBuilder<TContext extends Context = Context> = Omit<BaseQueryBuilder<TContext>, 'from' | '_getQuery'>;
+type RefsForContext<TContext extends Context> = RefContext<TContext> & (TContext extends {
+    hasResult: true;
+    result: infer TResult;
+} ? {
+    $selected: SingleRowRefProxy<TResult & Record<string, unknown>> & Record<string, any>;
+} : {});
+type WhereCallback<TContext extends Context> = (refs: RefsForContext<TContext>) => unknown;
+type SelectObject<T extends Record<string, unknown> = Record<string, unknown>> = T;
+type OrderByCallback<TContext extends Context> = (refs: RefsForContext<TContext>) => unknown;
+type GroupByCallback<TContext extends Context> = (refs: RefsForContext<TContext>) => unknown;
+type JoinOnCallback<TContext extends Context> = (refs: RefsForContext<TContext>) => unknown;
+type FunctionalHavingRow<TContext extends Context> = TContext['schema'] & (TContext extends {
+    hasResult: true;
+    result: infer TResult;
+} ? {
+    $selected: TResult;
+} : {});
+type RefContext<_TContext extends Context> = RootRefProxy<any> & Record<string, any>;
+type HavingCallback<TContext extends Context> = (refs: RefsForContext<TContext>) => unknown;
+type JoinCallback<TContext extends Context> = JoinOnCallback<TContext>;
+type OrderByOptions = 'asc' | 'desc' | (Partial<CompareOptions> & {
+    direction?: 'asc' | 'desc';
+    nulls?: 'first' | 'last';
+});
+type QueryDraft = Omit<Partial<QueryIR>, 'select' | 'where' | 'having' | 'groupBy' | 'orderBy' | 'join' | 'fnSelect' | 'fnWhere' | 'fnHaving'> & {
+    select?: Select | BasicExpression$1 | Aggregate | IncludesSubquery | undefined;
+    where?: Array<Where> | undefined;
+    having?: Array<Having> | undefined;
+    groupBy?: GroupBy | undefined;
+    orderBy?: OrderBy | undefined;
+    join?: QueryIR['join'] | undefined;
+    fnSelect?: ((row: Record<string, unknown>) => unknown) | undefined;
+    fnWhere?: Array<(row: Record<string, unknown>) => unknown> | undefined;
+    fnHaving?: Array<(row: Record<string, unknown>) => unknown> | undefined;
+};
+declare class BaseQueryBuilder<TContext extends Context = EmptyContext> {
+    /** Phantom type carrier for structural result/context inference. */
+    readonly __context: TContext;
+    private readonly query;
+    constructor(query?: QueryDraft);
+    from<TSource extends SourceRecord>(source: TSource): BaseQueryBuilder<{
+        baseSchema: SchemaFromSource<TSource>;
+        schema: SchemaFromSource<TSource>;
+        fromSourceName: keyof TSource & string;
+        hasJoins: false;
+    }>;
+    join<TSource extends SourceRecord, TJoinType extends JoinType$1 = 'left'>(source: TSource, onCallback: JoinCallback<MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>>, type?: TJoinType): BaseQueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>>;
+    innerJoin<TSource extends SourceRecord>(source: TSource, onCallback: JoinCallback<MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>>): BaseQueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, 'inner'>>;
+    leftJoin<TSource extends SourceRecord>(source: TSource, onCallback: JoinCallback<MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>>): BaseQueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, 'left'>>;
+    rightJoin<TSource extends SourceRecord>(source: TSource, onCallback: JoinCallback<MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>>): BaseQueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, 'right'>>;
+    fullJoin<TSource extends SourceRecord>(source: TSource, onCallback: JoinCallback<MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>>): BaseQueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, 'full'>>;
+    where(callback: WhereCallback<TContext>): BaseQueryBuilder<TContext>;
+    select<TSelect>(callback: (refs: RefsForContext<TContext>) => TSelect): BaseQueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelect>>>;
+    groupBy(callback: GroupByCallback<TContext>): BaseQueryBuilder<TContext>;
+    having(callback: HavingCallback<TContext>): BaseQueryBuilder<TContext>;
+    orderBy(callback: OrderByCallback<TContext>, options?: OrderByOptions): BaseQueryBuilder<TContext>;
+    limit(limit: number): BaseQueryBuilder<TContext>;
+    offset(offset: number): BaseQueryBuilder<TContext>;
+    distinct(): BaseQueryBuilder<TContext>;
+    findOne(): BaseQueryBuilder<TContext & {
+        singleResult: true;
+    }>;
+    get fn(): {
+        select: <TFuncSelectResult>(callback: (row: TContext['schema']) => TFuncSelectResult) => BaseQueryBuilder<WithResult<TContext, TFuncSelectResult>>;
+        where: (callback: (row: TContext['schema']) => unknown) => BaseQueryBuilder<TContext>;
+        having: (callback: (row: FunctionalHavingRow<TContext>) => unknown) => BaseQueryBuilder<TContext>;
+    };
+    _getQuery(): QueryIR;
+    private appendJoin;
+    private aliases;
+}
+declare const Query: typeof BaseQueryBuilder;
+declare function buildQuery<TQuery extends BaseQueryBuilder<any>>(fn: (q: InitialQueryBuilder) => TQuery): QueryIR;
+declare function getQueryIR(builder: BaseQueryBuilder<any>): QueryIR;
+
+/**
+ * QueryIR compiler — Layer C.5.
+ *
+ * Executes the TanStack-compatible QueryIR produced by builder.ts
+ * against ArrowBase collections. This is intentionally a coarse
+ * batch compiler: `runCollection()` materializes a result array, and
+ * `runLive()` re-runs the whole query on any upstream collection
+ * change. Layer F replaces that coarse invalidation with IVM.
+ */
+
+type ResultRow = unknown;
+type CompiledExpression = (row: Record<string, unknown>) => unknown;
+interface IncludesCompilationResult {
+    pipeline: Array<ResultRow>;
+    fieldName: string;
+    correlationField: PropRef;
+    childCorrelationField: PropRef;
+    hasOrderBy: boolean;
+    childCompilationResult: CompilationResult;
+    parentProjection?: Array<PropRef>;
+    materialization: IncludesMaterialization;
+    scalarField?: string;
+}
+interface CompilationResult {
+    collectionId: string;
+    pipeline: Array<ResultRow>;
+    sourceWhereClauses: Map<string, BasicExpression$1<boolean>>;
+    aliasToCollectionId: Record<string, string>;
+    aliasRemapping: Record<string, string>;
+    includes?: Array<IncludesCompilationResult>;
+}
+/** Execute a QueryIR once and return dense result rows. */
+declare function runCollection(ir: QueryIR): Array<ResultRow>;
+/**
+ * Compile QueryIR into a stable Layer-C result envelope. The pipeline is
+ * the current batch-compiler output; metadata mirrors TanStack's compiler
+ * shape so optimizer/conformance code has the same public handles.
+ */
+declare function compileQuery(rawQuery: QueryIR, ..._unused: Array<unknown>): CompilationResult;
+/**
+ * Coarse live runner: emit initial result, then re-run after any
+ * upstream source mutation. Returns unsubscribe.
+ */
+declare function runLive(ir: QueryIR, callback: (rows: Array<ResultRow>) => void): () => void;
+/** Compile a scalar expression evaluator over a namespaced row. */
+declare function compileExpression(expr: BasicExpression$1): CompiledExpression;
+/** Compile a scalar expression over a plain single row. */
+declare function compileSingleRowExpression(expr: BasicExpression$1): CompiledExpression;
+/** TanStack truthiness helper: only literal `true` passes filters. */
+declare function toBooleanPredicate(value: unknown): boolean;
+
+/**
+ * Conservative Layer-C subset check. Exact predicates are subsets of each other;
+ * an undefined superset means "all rows", so any subset matches.
+ */
+declare function isWhereSubset(subset: BasicExpression$1<boolean> | undefined, superset: BasicExpression$1<boolean> | undefined): boolean;
+/** Combine predicates with OR. Kept intentionally simple until Layer D optimizer work. */
+declare function unionWherePredicates(predicates: Array<BasicExpression$1<boolean>>): BasicExpression$1<boolean>;
+/** Return `fromPredicate AND NOT(subtractPredicate)` when both are present. */
+declare function minusWherePredicates(fromPredicate: BasicExpression$1<boolean> | undefined, subtractPredicate: BasicExpression$1<boolean> | undefined): BasicExpression$1<boolean> | null;
+/** Order subset is satisfied when the requested order is a prefix of the loaded order. */
+declare function isOrderBySubset(subset: OrderBy | undefined, superset: OrderBy | undefined): boolean;
+/** Limited request is a subset of an equal/larger or unlimited loaded request. */
+declare function isLimitSubset(subset: number | undefined, superset: number | undefined): boolean;
+/** Offset+limit subset over half-open ranges [offset, offset + limit). */
+declare function isOffsetLimitSubset(subset: {
+    offset?: number;
+    limit?: number;
+}, superset: {
+    offset?: number;
+    limit?: number;
+}): boolean;
+/** Combined predicate subset check used by subset-load dedupe. */
+declare function isPredicateSubset(subset: LoadSubsetOptions, superset: LoadSubsetOptions): boolean;
+
+/**
+ * Deduplicated wrapper for loadSubset. Conservative Layer-C version:
+ * skips requests already covered by completed loads; async calls are tracked
+ * after resolution. Layer D/F can replace this with richer predicate algebra.
+ */
+declare class DeduplicatedLoadSubset {
+    private readonly _loadSubset;
+    private readonly onDeduplicate;
+    private loaded;
+    private generation;
+    constructor(opts: {
+        loadSubset: (options: LoadSubsetOptions) => true | Promise<void>;
+        onDeduplicate?: (options: LoadSubsetOptions) => void;
+    });
+    loadSubset: (options: LoadSubsetOptions) => true | Promise<void>;
+    reset(): void;
+}
+
+/**
+ * queryOnce — Layer C.6.
+ *
+ * Thin TanStack-compatible one-shot query helper. The upstream runtime
+ * builds a live query collection, preloads it, reads rows, then cleans
+ * up. ArrowBase's Layer-C equivalent can run the QueryIR compiler
+ * directly because live collection wrapping lands in C.7.
+ */
+
+type QueryOnceResult<TQuery extends BaseQueryBuilder<any>> = ExtractContext<TQuery> extends {
+    singleResult: true;
+} ? QueryResult<TQuery> | undefined : Array<QueryResult<TQuery>>;
+type QueryOnceQuery<TQuery extends BaseQueryBuilder<any>> = ((q: InitialQueryBuilder) => TQuery) | TQuery;
+/** Configuration options for queryOnce. */
+interface QueryOnceConfig<TQuery extends BaseQueryBuilder<any> = BaseQueryBuilder<any>> {
+    /** Query builder callback or pre-built query builder. */
+    query: QueryOnceQuery<TQuery>;
+}
+/** Execute a one-shot query builder callback and return its result rows. */
+declare function queryOnce<TQuery extends BaseQueryBuilder<any>>(queryFn: (q: InitialQueryBuilder) => TQuery): Promise<QueryOnceResult<TQuery>>;
+/** Execute a one-shot query from a config object. */
+declare function queryOnce<TQuery extends BaseQueryBuilder<any>>(config: QueryOnceConfig<TQuery>): Promise<QueryOnceResult<TQuery>>;
+
+interface ColumnarBackendStats {
+    readonly backend: 'columnar-differential';
+    sourceHandles: number;
+    sourceRowsMaterialized: number;
+    outputRowsMaterialized: number;
+    additions: number;
+    retractions: number;
+    spatialIndexUsed: boolean;
+}
+
+/**
+ * TanStack-compatible live query collection backed by signed,
+ * differential updates for the structural query subset. Queries outside
+ * that subset retain the batch compiler as a correctness fallback.
+ */
+
+interface WindowOptions {
+    offset?: number;
+    limit?: number;
+}
+declare const LIVE_QUERY_INTERNAL: unique symbol;
+interface LiveQueryInternalUtils {
+    getBuilder: () => LiveQueryController;
+    getBackendStats: () => ColumnarBackendStats | {
+        readonly backend: 'batch';
+    };
+    hasCustomGetKey: boolean;
+    hasJoins: boolean;
+    hasDistinct: boolean;
+}
+type LiveQueryCollectionUtils = UtilsRecord & {
+    getRunCount: () => number;
+    setWindow: (options: WindowOptions) => true | Promise<void>;
+    getWindow: () => {
+        offset: number;
+        limit: number;
+    } | undefined;
+    [LIVE_QUERY_INTERNAL]: LiveQueryInternalUtils;
+};
+type LiveQueryKey = string | number;
+type LiveQueryRow = Record<string, unknown>;
+interface LiveQueryCollectionConfig<TQuery extends BaseQueryBuilder<any> = BaseQueryBuilder<any>, TResult extends object = QueryResult<TQuery> extends object ? QueryResult<TQuery> : LiveQueryRow> {
+    id?: string;
+    query: ((q: InitialQueryBuilder) => TQuery) | TQuery;
+    getKey?: (item: TResult) => LiveQueryKey;
+    utils?: UtilsRecord;
+    schema?: unknown;
+    capacity?: number;
+    gcTime?: number;
+    startSync?: boolean;
+    singleResult?: true;
+    defaultStringCollation?: StringCollationConfig;
+    onInsert?: unknown;
+    onUpdate?: unknown;
+    onDelete?: unknown;
+}
+interface LiveQueryCollectionOptions<TQuery extends BaseQueryBuilder<any> = BaseQueryBuilder<any>, TResult extends object = QueryResult<TQuery> extends object ? QueryResult<TQuery> : LiveQueryRow> {
+    id: string;
+    query: ((q: InitialQueryBuilder) => TQuery) | TQuery;
+    queryIR: QueryIR;
+    getKey?: (item: TResult) => LiveQueryKey;
+    utils: LiveQueryCollectionUtils;
+    schema?: unknown;
+    capacity?: number;
+    gcTime: number;
+    startSync?: boolean;
+    singleResult?: true;
+    defaultStringCollation?: StringCollationConfig;
+    onInsert?: unknown;
+    onUpdate?: unknown;
+    onDelete?: unknown;
+    controller: LiveQueryController;
+}
+type LiveQueryChange = ChangeMessage<LiveQueryRow, LiveQueryKey>;
+type LowLevelListener = (event: {
+    op: 'insert' | 'update' | 'delete' | 'reset';
+    changes: Array<LiveQueryChange>;
+    globalVersion: number;
+}) => void;
+declare class LiveQueryController {
+    readonly id: string;
+    readonly query: QueryIR;
+    readonly hasCustomGetKey: boolean;
+    readonly hasJoins: boolean;
+    readonly hasDistinct: boolean;
+    readonly compareOptions: StringCollationConfig | undefined;
+    private readonly keyFn;
+    private _runCount;
+    private _window;
+    private onWindowChange;
+    private backendStats;
+    constructor(options: {
+        id: string;
+        query: QueryIR;
+        getKey?: (item: LiveQueryRow) => LiveQueryKey;
+        compareOptions?: StringCollationConfig;
+    });
+    getRunCount(): number;
+    recordRun(): void;
+    setBackendStats(provider: () => ColumnarBackendStats | {
+        readonly backend: 'batch';
+    }): void;
+    getBackendStats(): ColumnarBackendStats | {
+        readonly backend: 'batch';
+    };
+    setWindow(options: WindowOptions): true;
+    getWindow(): {
+        offset: number;
+        limit: number;
+    } | undefined;
+    getEffectiveQuery(): QueryIR;
+    setWindowChangeListener(listener: (() => void) | undefined): void;
+    runRows(): Array<LiveQueryRow>;
+    getKey(row: LiveQueryRow, index: number): LiveQueryKey;
+    private effectiveQuery;
+}
+declare class LiveQueryCollection<TRow extends LiveQueryRow = LiveQueryRow, TKey extends LiveQueryKey = LiveQueryKey, TUtils extends UtilsRecord = {}> {
+    readonly id: string;
+    readonly utils: LiveQueryCollectionUtils & TUtils;
+    readonly compareOptions: StringCollationConfig;
+    readonly config: LiveQueryCollectionOptions;
+    private readonly controller;
+    private readonly sourceUnsubs;
+    private readonly listeners;
+    private readonly lowLevelListeners;
+    private rowsCache;
+    private stateCache;
+    private ivmPlan;
+    private _subscriberCount;
+    private _status;
+    private _globalVersion;
+    constructor(options: LiveQueryCollectionOptions<any, any>, customUtils?: TUtils);
+    get status(): 'ready' | 'cleaned-up';
+    get size(): number;
+    get rowCount(): number;
+    get globalVersion(): number;
+    get subscriberCount(): number;
+    get state(): Map<TKey, TRow>;
+    get toArray(): Array<TRow>;
+    get(key: TKey): TRow | undefined;
+    has(key: TKey): boolean;
+    keys(): IterableIterator<TKey>;
+    values(): IterableIterator<TRow>;
+    entries(): IterableIterator<[TKey, TRow]>;
+    forEach(callback: (value: TRow, key: TKey, index: number) => void): void;
+    map<U>(callback: (value: TRow, key: TKey, index: number) => U): Array<U>;
+    currentStateAsChanges(): Array<ChangeMessage<TRow, TKey>>;
+    subscribeChanges(callback: (changes: Array<ChangeMessage<TRow, TKey>>) => void, options?: SubscribeChangesOptions): CollectionSubscription;
+    subscribe(listener: LowLevelListener): () => void;
+    preload(): Promise<void>;
+    stateWhenReady(): Promise<Map<TKey, TRow>>;
+    toArrayWhenReady(): Promise<Array<TRow>>;
+    isReady(): boolean;
+    startSyncImmediate(): void;
+    cleanup(): Promise<void>;
+    private recompute;
+    private resetForWindowChange;
+    private seedIvmPlan;
+    private applyIvmChanges;
+    private applyWeightsToPlan;
+    private applyWeightedOutputChanges;
+    private replaceCachedRow;
+    private removeCachedRow;
+    private replaceRows;
+    private sortRows;
+    private emitChanges;
+}
+declare function liveQueryCollectionOptions<TQuery extends BaseQueryBuilder<any>, TResult extends object = QueryResult<TQuery> extends object ? QueryResult<TQuery> : LiveQueryRow>(config: LiveQueryCollectionConfig<TQuery, TResult>): LiveQueryCollectionOptions<TQuery, TResult>;
+declare function createLiveQueryCollection<TQuery extends BaseQueryBuilder<any>, TContext = ExtractContext<TQuery>, TResult extends object = QueryResult<TQuery> extends object ? QueryResult<TQuery> : LiveQueryRow, TUtils extends UtilsRecord = {}>(query: ((q: InitialQueryBuilder) => TQuery)): LiveQueryCollection<TResult & LiveQueryRow, LiveQueryKey, {}> & {
+    utils: LiveQueryCollectionUtils;
+};
+declare function createLiveQueryCollection<TQuery extends BaseQueryBuilder<any>, TContext = ExtractContext<TQuery>, TResult extends object = QueryResult<TQuery> extends object ? QueryResult<TQuery> : LiveQueryRow, TUtils extends UtilsRecord = {}>(config: LiveQueryCollectionConfig<TQuery, TResult> & {
+    utils?: TUtils;
+}): LiveQueryCollection<TResult & LiveQueryRow, LiveQueryKey, TUtils> & {
+    utils: LiveQueryCollectionUtils & TUtils;
+};
+
+/** Options for BasicIndex. */
+interface BasicIndexOptions {
+    compareFn?: (a: unknown, b: unknown) => number;
+    compareOptions?: CompareOptions;
+}
+/**
+ * Basic index using Map + sorted array.
+ *
+ * Map gives O(1) equality lookup; sorted values give simple range/take support.
+ */
+declare class BasicIndex<TKey extends string | number = string | number> extends BaseIndex<TKey> {
+    readonly supportedOperations: Set<"eq" | "gt" | "gte" | "lt" | "lte" | "in" | "like" | "ilike">;
+    private valueMap;
+    private sortedValues;
+    private indexedKeys;
+    private compareFn;
+    constructor(id: number, expression: BasicExpression$1, name?: string, options?: BasicIndexOptions);
+    protected initialize(_options?: BasicIndexOptions): void;
+    add(key: TKey, item: unknown): void;
+    remove(key: TKey, item: unknown): void;
+    update(key: TKey, oldItem: unknown, newItem: unknown): void;
+    build(entries: Iterable<[TKey, unknown]>): void;
+    clear(): void;
+    lookup(operation: IndexOperation, value: unknown): Set<TKey>;
+    get keyCount(): number;
+    equalityLookup(value: unknown): Set<TKey>;
+    rangeQuery(options?: RangeQueryOptions): Set<TKey>;
+    rangeQueryReversed(options?: RangeQueryOptions): Set<TKey>;
+    take(n: number, from?: unknown, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    takeReversed(n: number, from?: unknown, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    takeFromStart(n: number, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    takeReversedFromEnd(n: number, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    inArrayLookup(values: Array<unknown>): Set<TKey>;
+    get indexedKeysSet(): Set<TKey>;
+    get orderedEntriesArray(): Array<[unknown, Set<TKey>]>;
+    get orderedEntriesArrayReversed(): Array<[unknown, Set<TKey>]>;
+    get valueMapData(): Map<unknown, Set<TKey>>;
+    private takeKeysForValue;
+}
+
+/** Options for BTreeIndex. */
+interface BTreeIndexOptions extends BasicIndexOptions {
+}
+/**
+ * Sorted index API-compatible with TanStack's BTreeIndex.
+ *
+ * ArrowBase keeps the implementation compact for D.1 by reusing the same
+ * sorted-value map as BasicIndex; D.2 plugs this into query planning, and future
+ * work can swap internals without changing the public contract.
+ */
+declare class BTreeIndex<TKey extends string | number = string | number> extends BasicIndex<TKey> {
+    constructor(id: number, expression: BasicExpression$1, name?: string, options?: BTreeIndexOptions);
+}
+
+/** View of an existing index with traversal/comparison direction reversed. */
+declare class ReverseIndex<TKey extends string | number = string | number> implements IndexInterface<TKey> {
+    private readonly originalIndex;
+    constructor(originalIndex: IndexInterface<TKey>);
+    lookup(operation: IndexOperation, value: unknown): Set<TKey>;
+    rangeQuery(options?: RangeQueryOptions): Set<TKey>;
+    rangeQueryReversed(options?: RangeQueryOptions): Set<TKey>;
+    take(n: number, from?: unknown, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    takeFromStart(n: number, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    takeReversed(n: number, from?: unknown, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    takeReversedFromEnd(n: number, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    get orderedEntriesArray(): Array<[unknown, Set<TKey>]>;
+    get orderedEntriesArrayReversed(): Array<[unknown, Set<TKey>]>;
+    supports(operation: IndexOperation): boolean;
+    matchesField(fieldPath: Array<string>): boolean;
+    matchesCompareOptions(compareOptions: CompareOptions): boolean;
+    matchesDirection(direction: OrderByDirection): boolean;
+    getStats(): IndexStats;
+    add(key: TKey, item: unknown): void;
+    remove(key: TKey, item: unknown): void;
+    update(key: TKey, oldItem: unknown, newItem: unknown): void;
+    build(entries: Iterable<[TKey, unknown]>): void;
+    clear(): void;
+    get keyCount(): number;
+    equalityLookup(value: unknown): Set<TKey>;
+    inArrayLookup(values: Array<unknown>): Set<TKey>;
+    get indexedKeysSet(): Set<TKey>;
+    get valueMapData(): Map<unknown, Set<TKey>>;
+}
+
+interface IndexInfo<T extends object = Record<string, unknown>> {
+    index: IndexInterface<number>;
+    collection?: Collection;
+    expression?: BasicExpression$1;
+    fieldPath?: Array<string>;
+    sample?: T;
+}
+interface OptimizationResult<T extends object = Record<string, unknown>> {
+    canOptimize: boolean;
+    matchingKeys: Set<number>;
+    indexes: Array<IndexInterface<number>>;
+    residualExpression?: BasicExpression$1;
+}
+type IndexSource<T extends object = Record<string, unknown>> = (Collection & {
+    indexes: ReadonlyMap<unknown, IndexInterface<number> | IndexInfo<T>>;
+}) | ReadonlyMap<unknown, IndexInterface<number> | IndexInfo<T>>;
+declare function findIndexForField<T extends object = Record<string, unknown>>(source: IndexSource<T>, fieldName: string | Array<string>, valueOrCompareOptions?: unknown | CompareOptions, operation?: IndexOperation, compareOptions?: CompareOptions): IndexInterface<number> | undefined;
+declare function optimizeExpressionWithIndexes<T extends object = Record<string, unknown>>(expression: BasicExpression$1, source: IndexSource<T>, _rowMap?: Map<number, T>, _collection?: Collection, _lazyCollection?: Collection): OptimizationResult<T>;
+
+/**
+ * Index Dev Mode — TanStack DB parity (Layer D.3).
+ *
+ * Tracks slow query patterns and emits index suggestions in non-production
+ * builds. Public root exports intentionally mirror @tanstack/db@0.6.16.
+ */
+interface IndexDevModeConfig {
+    /** Enable dev mode index suggestions. */
+    enabled: boolean;
+    /** Suggest indexes when collection has more than this many items. */
+    collectionSizeThreshold: number;
+    /** Suggest indexes when queries take longer than this many milliseconds. */
+    slowQueryThresholdMs: number;
+    /** Custom handler for index suggestions. */
+    onSuggestion: ((suggestion: IndexSuggestion) => void) | null;
+}
+interface IndexSuggestion {
+    type: 'collection-size' | 'slow-query' | 'frequent-field';
+    collectionId: string;
+    fieldPath: Array<string>;
+    message: string;
+    collectionSize?: number;
+    queryTimeMs?: number;
+    queryCount?: number;
+}
+interface QueryPattern {
+    fieldPath: Array<string>;
+    queryCount: number;
+    totalTimeMs: number;
+    avgTimeMs: number;
+}
+/** Configure dev mode for index suggestions. */
+declare function configureIndexDevMode(config: Partial<IndexDevModeConfig>): void;
+/** Get current dev mode configuration. */
+declare function getIndexDevModeConfig(): IndexDevModeConfig;
+/** Check if dev mode is enabled. */
+declare function isDevModeEnabled(): boolean;
+/** Track a query for dev mode analysis. */
+declare function trackQuery(collectionId: string, fieldPath: Array<string>, executionTimeMs: number): void;
+/** Clear query pattern tracking (useful for tests). */
+declare function clearQueryPatterns(): void;
+/** Get query patterns (useful for debugging/testing). */
+declare function getQueryPatterns(): Map<string, QueryPattern>;
+
+/**
+ * Dependency-tracking row proxy for filter predicates.
+ *
+ * The query engine calls `trackRow(realRow, deps)` to wrap a concrete row
+ * JS object before passing it to the user's predicate. Every property read
+ * adds the key to `deps` so the query can record which columns it observes.
+ *
+ * Known limitations:
+ *   - Only string-keyed reads are recorded. Symbol reads (Symbol.iterator,
+ *     Symbol.toPrimitive, etc.) are forwarded to the underlying row and
+ *     ignored for dep tracking.
+ *   - If the predicate reads nested objects (lists, structs), only the
+ *     top-level column name is recorded. That matches the granularity of
+ *     our column-level invalidation anyway.
+ *   - Returning the underlying scalar value directly means JS operators
+ *     (`===`, `>`, arithmetic) behave as the user expects.
+ */
+type DepSet = Set<string>;
+declare function trackRow<T extends object>(row: T, deps: DepSet): T;
+
+interface LiveQueryStatusFlags {
+    isLoading: boolean;
+    isReady: boolean;
+    isIdle: boolean;
+    isError: boolean;
+    isCleanedUp: boolean;
+}
+declare function isCollection(value: unknown): boolean;
+declare function isSingleResultCollection(collection: {
+    config?: {
+        singleResult?: boolean;
+    };
+}): boolean;
+declare function getLiveQueryStatusFlags(status: CollectionStatus): LiveQueryStatusFlags;
+
+declare function safeRandomUUID(): string;
+
+declare function bboxIntersects(geometry: unknown, bbox: BBox): BasicExpression$1<boolean>;
+declare function bboxWithin(geometry: unknown, bbox: BBox): BasicExpression$1<boolean>;
+declare function dwithin(geometry: unknown, point: Point, meters: number): BasicExpression$1<boolean>;
+declare function within(point: unknown, polygon: unknown): BasicExpression$1<boolean>;
+declare function contains(polygon: unknown, point: unknown): BasicExpression$1<boolean>;
+
+/** Field path extracted from a query expression. */
+type FieldPath = Array<string>;
+/** Simple field/operator/value comparison extracted from a WHERE expression. */
+interface SimpleComparison {
+    field: FieldPath;
+    operator: string;
+    value?: unknown;
+}
+/** Custom parser hooks for WHERE expression conversion. */
+interface ParseWhereOptions<T = unknown> {
+    handlers: Partial<Record<OperatorName | string, (...args: Array<any>) => T>>;
+    onUnknownOperator?: (operator: string, args: Array<unknown>) => T;
+}
+/** Parsed ORDER BY field + compare options. */
+interface ParsedOrderBy {
+    field: FieldPath;
+    direction: 'asc' | 'desc';
+    nulls: 'first' | 'last';
+    stringSort?: 'lexical' | 'locale';
+    locale?: string;
+    localeOptions?: object;
+}
+/** Extracts the field path from a PropRef expression. */
+declare function extractFieldPath(expr: BasicExpression$1): FieldPath | null;
+/** Extracts the literal value from a Value expression. */
+declare function extractValue(expr: BasicExpression$1): unknown;
+/** Walks a scalar expression tree depth-first. */
+declare function walkExpression(expr: BasicExpression$1 | undefined | null, visitor: (node: BasicExpression$1) => void): void;
+/** Parses a WHERE expression through user-supplied operator handlers. */
+declare function parseWhereExpression<T = unknown>(expr: BasicExpression$1<boolean> | undefined | null, options: ParseWhereOptions<T>): T | null;
+/** Parses ORDER BY IR clauses into field/direction/null-order records. */
+declare function parseOrderByExpression(orderBy: OrderBy | undefined | null): Array<ParsedOrderBy>;
+/** Extracts simple AND-ed field comparisons from a WHERE expression. */
+declare function extractSimpleComparisons(expr: BasicExpression$1<boolean> | undefined | null): Array<SimpleComparison>;
+/** Parses load-subset options into filters/sorts/limit. */
+declare function parseLoadSubsetOptions(options: {
+    where?: BasicExpression$1<boolean>;
+    orderBy?: OrderBy;
+    limit?: number;
+} | undefined | null): {
+    filters: Array<SimpleComparison>;
+    sorts: Array<ParsedOrderBy>;
+    limit?: number;
+};
+
+/**
+ * Hash-join across two collections.
+ *
+ * Given a "left" Query and a "right" Collection, emit the equi-join of
+ * left.rows × right.rows on a pair of key columns. The right side is
+ * hashed; the left side (post-filter) probes into the hash. We pick the
+ * right side as the build side unconditionally — callers can reorder
+ * manually if they know which side is smaller.
+ *
+ * ### Join types
+ *
+ * - `inner`  — emit only matched pairs.
+ * - `left`   — emit every left row; unmatched get `{ [as]: null }`.
+ * - `right`  — emit every right row; unmatched right get no left
+ *              columns at all (they are `undefined`, not `null` —
+ *              matching SQL's NULL-on-projection semantics when
+ *              consumers read absent left columns).
+ * - `full`   — union of left and right.
+ *
+ * ### Output row shape
+ *
+ * Nested, not flattened:
+ *
+ *   { ...leftRow, [as]: rightRow }
+ *
+ * This avoids column-name collisions cleanly and keeps the output row
+ * shape independent of the two schemas (useful for TypeScript generics
+ * later). Selection, filtering, and ordering after the join all work
+ * against this nested shape via bracket/dot access on the row object.
+ *
+ * Unmatched markers:
+ *
+ * - `left`/`full`, left row with no right match → `{...leftRow, [as]: null}`.
+ *   Use `row[as] === null` to detect "no match".
+ * - `right`/`full`, right row with no left match → `{[as]: rightRow}`.
+ *   Left columns are absent; access yields `undefined`.
+ *
+ * ### Pipeline
+ *
+ * 1. Run left's vectorized filter kernel to shrink the left ordinal set.
+ * 2. Materialize left rows (only the columns needed for the probe +
+ *    downstream filter/select/order).
+ * 3. Build a Map<keyValue, rightOrdinal[]> from the right side.
+ * 4. Probe: for each left row, emit one joined row per matching right
+ *    ordinal. Right rows are lazily materialized. For left/full, emit
+ *    an unmatched left row when there are no matches.
+ * 5. For right/full, iterate the right side and emit any ordinal not
+ *    previously matched.
+ * 6. Apply post-join filter / sort / limit in plain JS (v1).
+ *
+ * ### Reactivity
+ *
+ * JoinExecutor subscribes to BOTH collections. Any mutation on either
+ * side invalidates the cached snapshot. No incremental updates in v1.
+ *
+ * ### Non-goals (v1)
+ *
+ * - Multi-column join keys. Single column per side.
+ * - Vectorized post-join filter. We materialize then filter in JS.
+ * - Incremental recompute. Any change on either side triggers a full
+ *   rebuild of the hash + probe.
+ */
+
+type JoinType = 'inner' | 'left' | 'right' | 'full';
+interface JoinOn {
+    /** Column on the left (probe) side. */
+    readonly left: string;
+    /** Column on the right (build) side. */
+    readonly right: string;
+}
+interface JoinSpec {
+    readonly on: JoinOn;
+    /** Namespace under which the right row is attached in the output. */
+    readonly as: string;
+    /**
+     * Join type. Defaults to `'inner'`. `'left'` / `'right'` / `'full'`
+     * emit null-padded rows for unmatched sides:
+     * - `left`  — every left row is emitted; right side is `null` if no match.
+     * - `right` — every right row is emitted; left columns absent if no match.
+     * - `full`  — union of left and right.
+     */
+    readonly type?: JoinType;
+}
+interface JoinedQuerySnapshot<TRow extends RowValue = RowValue> {
+    readonly rows: readonly TRow[];
+    /** `Math.max(left.globalVersion, right.globalVersion)` at snapshot time. */
+    readonly version: number;
+}
+/**
+ * A query plan with one join. Mirrors the Query builder API shape for
+ * the operations that make sense post-join: `where`, `select`,
+ * `orderBy`, `limit`, `offset`. Nested keys are addressed with dot
+ * notation in selection/order (e.g., `'user.name'`).
+ */
+declare class JoinQuery<TRow extends RowValue = RowValue> {
+    readonly left: Query$1;
+    readonly right: Collection;
+    readonly spec: JoinSpec;
+    readonly predicate: Predicate$1 | null;
+    readonly selection: readonly string[] | null;
+    readonly order: readonly OrderSpec[];
+    readonly limitN: number | null;
+    readonly offsetN: number;
+    constructor(left: Query$1, right: Collection, spec: JoinSpec, predicate?: Predicate$1 | null, selection?: readonly string[] | null, order?: readonly OrderSpec[], limitN?: number | null, offsetN?: number);
+    /**
+     * Post-join filter. The predicate receives a fully-formed joined
+     * row (with `row[spec.as]` as the nested right side).
+     */
+    where(predicate: Predicate$1): JoinQuery<TRow>;
+    /**
+     * Project columns. Paths may be plain column names (from the left
+     * side) or `'<as>.<col>'` for the right side.
+     */
+    select(columns: readonly string[]): JoinQuery<TRow>;
+    orderBy(column: string, dir?: SortDir): JoinQuery<TRow>;
+    limit(n: number): JoinQuery<TRow>;
+    offset(n: number): JoinQuery<TRow>;
+    private requireKnownPath;
+}
+/**
+ * Build + probe executor. Re-runs on any mutation to either collection.
+ * Caches the last snapshot keyed by (leftVersion, rightVersion).
+ */
+declare class JoinExecutor<TRow extends RowValue = RowValue> {
+    readonly plan: JoinQuery<TRow>;
+    private cached;
+    private cachedLeftVersion;
+    private cachedRightVersion;
+    constructor(plan: JoinQuery<TRow>);
+    dispose(): void;
+    snapshot(): JoinedQuerySnapshot<TRow>;
+    subscribe(listener: (snap: JoinedQuerySnapshot<TRow>) => void): () => void;
+    /**
+     * v1 reactivity is coarse: any mutation on either side triggers a
+     * full recompute. We still filter out no-op events (e.g., a column
+     * change on the left that isn't observed by the join). That's
+     * conservative enough — joins touch at minimum the two key columns
+     * plus every left/right column referenced in predicate/select/order.
+     */
+    private shouldReact;
+    /**
+     * We don't know which collection an event came from inside the
+     * listener's lexical scope once both are wired up — but the fix is
+     * simple: observe the UNION of both sides' watched columns. Extra
+     * recompute is cheap relative to a miss.
+     */
+    private observedColumnsForEventSide;
+    private recompute;
+    private leftColumnsToRead;
+    private rightColumnsToRead;
+}
+/**
+ * Attach a join to a Query. Returns a JoinQuery that supports the
+ * post-join builder surface (where / select / orderBy / limit / offset).
+ * Chaining a second `.join()` is **not** supported in v1 — only one
+ * join per query plan.
+ */
+declare function join<TLeft extends RowValue, TRight extends RowValue>(left: Query$1<TLeft>, right: Collection, spec: JoinSpec): JoinQuery<TLeft & Record<string, TRight>>;
+/** Build an executor for a JoinQuery. */
+declare function runJoin<TRow extends RowValue = RowValue>(plan: JoinQuery<TRow>): JoinExecutor<TRow>;
+
+/**
+ * A Segment wraps a single SharedArrayBuffer (or ArrayBuffer fallback) and
+ * manages bump allocation inside it. Allocations are 64-byte aligned to
+ * satisfy Arrow buffer alignment.
+ *
+ * Phase 1 uses only a bump allocator; freelist / compaction lands later.
+ */
+declare class Segment {
+    readonly buffer: SharedArrayBuffer | ArrayBuffer;
+    readonly byteLength: number;
+    private cursor;
+    constructor(buffer: SharedArrayBuffer | ArrayBuffer, 
+    /** Initial cursor position. Useful when rehydrating from a handoff. */
+    initialCursor?: number);
+    /** Remaining byte capacity from the current cursor. */
+    get remaining(): number;
+    /** Current bump cursor (byte offset of next allocation). */
+    get used(): number;
+    /**
+     * Allocate `byteLength` bytes aligned to `alignment` (default Arrow 64B).
+     * Returns the starting byte offset inside `buffer`.
+     * Throws `OutOfSpaceError` if the segment cannot fit the request.
+     */
+    allocate(byteLength: number, alignment?: number): number;
+    /** Return the underlying buffer as a typed view slice (copies the handle only). */
+    u8View(offset?: number, byteLength?: number): Uint8Array;
+    i32View(offset?: number, length?: number): Int32Array;
+}
+/** Create a Segment backed by SAB if available, else a plain ArrayBuffer. */
+declare function createSegment(byteLength: number): Segment;
+
+/**
+ * Helpers for atomic / packed 64-bit access and seqlock-style reads.
+ *
+ * Phase 1 is single-writer within a process; these helpers exist so we can
+ * evolve toward multi-writer and cross-worker use without refactoring the
+ * collection layer.
+ */
+/** Align a byte offset up to the given power-of-two boundary. */
+declare function alignUp(value: number, alignment: number): number;
+/** Arrow buffer alignment — 64 bytes per Arrow columnar format spec. */
+declare const ARROW_ALIGN = 64;
+
+/**
+ * Custom binary snapshot format for ArrowBase collections.
+ *
+ * Layout:
+ *   [ magic 'ARBS' | formatVersion u32 | schemaJsonLength u32 |
+ *     schemaJson utf-8 bytes |
+ *     per-column sections, in declaration order:
+ *       validity bytes       (pad to 8B)
+ *       primary buffer bytes (pad to 8B)
+ *       heap bytes           (pad to 8B, only for utf8/binary)
+ *   ]
+ *
+ * Dictionary tables (per dict_utf8 column) are stored as a string array
+ * inside schemaJson because they are small compared to the value buffers.
+ * Geo columns store only authoritative coordinate buffers; bbox caches are
+ * derived and rebuilt on import.
+ *
+ * This format is intentionally not Arrow IPC: it captures ArrowBase's
+ * ranged-offset layout directly so round-trip preserves O(1)-update
+ * semantics without rebuilding dense offsets.
+ */
+declare const SNAPSHOT_MAGIC = 1396855361;
+declare const SNAPSHOT_FORMAT_VERSION = 3;
+/** Alignment pad applied to each section boundary in the snapshot. */
+declare const SNAPSHOT_ALIGN = 8;
+declare function alignSnapshot(offset: number): number;
+/** Per-column metadata stored in the JSON header. */
+interface SnapshotColumnMeta {
+    readonly name: string;
+    readonly type: string;
+    readonly nullable: boolean;
+    readonly validityBytes: number;
+    readonly primaryBytes: number;
+    readonly heapBytes?: number;
+    /** Ordered dictionary values for dict_utf8 columns. */
+    readonly dictionary?: readonly string[];
+    /**
+     * For list columns: the child-element meta + the number of child
+     * elements written (used to size the child buffers precisely). The
+     * child's `validityBytes`/`primaryBytes`/`heapBytes` describe its
+     * own storage sections; they are emitted right after the parent
+     * offsets section.
+     */
+    readonly listChildElements?: number;
+    readonly listChild?: SnapshotColumnMeta;
+    /**
+     * For struct columns: the per-field metas. Each field is serialized
+     * as a regular column section (validity + primary + optional heap
+     * + optional dictionary) directly after the struct parent's
+     * validity section.
+     */
+    readonly fields?: readonly SnapshotColumnMeta[];
+}
+/** JSON payload embedded in the snapshot header. */
+interface SnapshotHeaderJson {
+    readonly schemaName: string;
+    readonly primaryKey: string;
+    readonly capacity: number;
+    readonly rowCursor: number;
+    readonly columns: readonly SnapshotColumnMeta[];
+    readonly globalVersion: number;
+    /** Opaque tag the caller may set; not interpreted by the reader. */
+    readonly tag?: string;
+}
+
+/**
+ * Serialize a collection to a self-describing binary snapshot.
+ *
+ * Format v2 captures list + struct columns via nested metadata in the
+ * JSON header plus inline child/field buffer sections:
+ *
+ *   [ magic 'ARBS' | formatVersion u32 | schemaJsonLength u32 |
+ *     schemaJson utf-8 bytes |
+ *     per-column section (emitted recursively in declaration order) ]
+ *
+ * A leaf column section is `validity | primary | heap?` (each padded to
+ * 8 bytes). A list column section is `validity | offsets | childLeafSection`.
+ * A struct column section is `validity | field1Section | field2Section ...`.
+ */
+declare function exportSnapshot(abColl: Collection, options?: {
+    tag?: string;
+}): ArrayBuffer;
+/**
+ * Parse a snapshot header without touching payload bytes. Useful for
+ * verifying a snapshot's schema fingerprint before committing to
+ * importing it.
+ */
+declare function readSnapshotHeader(buffer: ArrayBuffer): SnapshotHeaderJson;
+/**
+ * Import a snapshot buffer into a fresh Collection. Row data is
+ * re-inserted through the normal mutation path so every invariant
+ * (row index, dictionary intern, validity bitmap, list child heap,
+ * struct field buffers) is rebuilt consistently.
+ */
+declare function importSnapshot(buffer: ArrayBuffer, factory: (schema: CompiledSchema, capacity: number) => Collection): Collection;
+/**
+ * Parses per-row values out of a snapshot without materializing a fresh
+ * Collection. Supports leaf, list, and struct columns (format v2).
+ */
+declare class SnapshotRowDecoder {
+    private readonly sections;
+    constructor(buffer: ArrayBuffer, header: SnapshotHeaderJson);
+    /** Returns a RowValue for the given row index, or null if the row
+     *  is soft-deleted AND the primary key column holds 0 (tombstone). */
+    read(row: number): RowValue | null;
+    private readValue;
+    private readListValue;
+    private readStructValue;
+}
+
+/**
+ * Records outgoing deltas from a Collection so a SyncAdapter can push
+ * them to a remote. Attaches to the collection's change feed on
+ * construction; call `dispose()` when done.
+ *
+ * `bufferLimit` caps the number of retained deltas — when exceeded the
+ * oldest entries are discarded. Consumers that may fall arbitrarily
+ * behind must call `drainSince(version)` fast enough, or they will see
+ * their cursor predate the log's oldest entry (surfaced as an empty
+ * return; a persistence-backed adapter should then resync via
+ * snapshot).
+ *
+ * `compact` and `rollback` events cannot be represented as incremental
+ * deltas. Callers receive a `{ type: 'resync', version }` sentinel via
+ * `onResync(listener)`, which prompts them to snapshot-sync instead of
+ * stream deltas.
+ */
+interface ChangeLogOptions {
+    /** Max deltas retained. Default 65536. */
+    bufferLimit?: number;
+}
+type ResyncListener = (event: {
+    version: number;
+}) => void;
+declare class ChangeLog {
+    private readonly abColl;
+    private readonly deltas;
+    private readonly bufferLimit;
+    private resyncListeners;
+    private readonly unsubscribe;
+    constructor(abColl: Collection, opts?: ChangeLogOptions);
+    dispose(): void;
+    /** Returns deltas with `version > sinceVersion`, in order. */
+    drainSince(sinceVersion: number): {
+        deltas: Delta[];
+        upTo: number;
+    };
+    /** Current number of retained deltas. */
+    get size(): number;
+    /** Register a resync listener (called on compact/rollback). */
+    onResync(listener: ResyncListener): () => void;
+    private onChange;
+    private push;
+}
+
+/**
+ * Apply an ordered list of deltas to a Collection, preserving order.
+ *
+ * Semantics:
+ *   - insert   → Collection.insert(delta.value). Duplicate key throws;
+ *                caller may want to retry via update. v1 is strict.
+ *   - update   → Collection.update(delta.key, delta.value).
+ *   - delete   → Collection.delete(delta.key). Missing key is ignored.
+ *
+ * Inserts with a key that already exists (because the local side wrote
+ * to the same key after the delta was emitted) are promoted to updates
+ * by default (TanStack DB does the same thing in its sync write path).
+ *
+ * Returns the highest version applied (or -Infinity if the list was empty).
+ */
+declare function applyDeltas(abColl: Collection, deltas: readonly Delta[]): number;
+/**
+ * In-memory sync adapter suitable for tests and same-process mirroring.
+ *
+ * Wraps two (or more) sides of a sync pair via a shared in-memory log.
+ * Each side gets its own `MemorySyncAdapter` instance that reads/writes
+ * the same log. `pull(since)` returns deltas newer than the cursor;
+ * `push(deltas)` appends to the log; `apply(deltas)` writes through to
+ * the local Collection.
+ *
+ * This is *not* a replica-set: there is no ordering guarantee beyond
+ * what callers themselves impose via `push` order. Last writer wins.
+ */
+declare class MemorySyncAdapter implements SyncAdapter {
+    private readonly local;
+    private readonly log;
+    /** Optional outbound change log; if provided, local mutations
+     *  auto-push into the shared log. */
+    private readonly outbound?;
+    constructor(local: Collection, log: SharedDeltaLog, 
+    /** Optional outbound change log; if provided, local mutations
+     *  auto-push into the shared log. */
+    outbound?: ChangeLog | undefined);
+    private disposeLocalListener;
+    dispose(): void;
+    apply(deltas: readonly Delta[]): Promise<void>;
+    pull(sinceVersion: number): Promise<{
+        deltas: Delta[];
+        upTo: number;
+    }>;
+    push(deltas: readonly Delta[]): Promise<void>;
+}
+/**
+ * Shared log of deltas for `MemorySyncAdapter`. Ordering is preserved
+ * by append order. No compaction — the log grows unboundedly. Tests
+ * only.
+ */
+declare class SharedDeltaLog {
+    private readonly entries;
+    push(deltas: readonly Delta[]): void;
+    drainSince(sinceVersion: number): {
+        deltas: Delta[];
+        upTo: number;
+    };
+    get size(): number;
+}
+
+/**
+ * Devtools-facing introspection snapshot of a Collection. Framework-free
+ * JSON — a future UI panel can render it without importing ArrowBase
+ * internals.
+ */
+interface CollectionDescription {
+    readonly schemaName: string;
+    readonly primaryKey: string;
+    readonly capacity: number;
+    readonly rowCount: number;
+    readonly liveRowCount: number;
+    readonly globalVersion: number;
+    readonly hasSoftDelete: boolean;
+    readonly schemaFingerprint: string;
+    readonly columns: readonly ColumnDescription[];
+}
+interface ColumnDescription {
+    readonly name: string;
+    readonly type: ColumnTypeName;
+    readonly nullable: boolean;
+    readonly version: number;
+    /** Count of rows whose validity bit is unset (for nullable columns). */
+    readonly nullCount: number;
+    /** Only present for utf8 / binary columns. */
+    readonly heap?: {
+        usedBytes: number;
+        capacityBytes: number;
+    };
+    /** Only present for dict_utf8 columns. */
+    readonly dictionary?: {
+        entries: number;
+        sampleEntries: readonly string[];
+    };
+}
+/**
+ * Return a structured description of a Collection for devtools /
+ * logging. Cheap to call — reads cached counters and allocates a small
+ * JS object. Safe to call on a hot path.
+ */
+declare function describeCollection(abColl: Collection): CollectionDescription;
+
+/**
+ * TanStack DB → ArrowBase push-down: translate a `BasicExpression<boolean>`
+ * into an ArrowBase predicate `(row) => boolean` when possible.
+ *
+ * v1 recognises:
+ *   - eq(prop, literal)      → row[col] === lit
+ *   - eq(literal, prop)      → row[col] === lit
+ *   - and(a, b, ...)         → every translated arg
+ *   - or(a, b, ...)          → some translated arg
+ *   - not(a)                 → !translated arg
+ *
+ * Any expression containing a node type that is not one of the above
+ * causes the translator to return `null`. Callers should treat `null`
+ * as "not pushable" and either fall back to full scan or let TanStack
+ * DB's own evaluator run against the materialized rows.
+ *
+ * `PropRef` paths are taken as `[alias, column]` when length === 2, or
+ * `[column]` when length === 1. Anything deeper (nested struct fields)
+ * is not supported in v1.
+ */
+
+type BasicExpression<T = unknown> = IR.BasicExpression<T>;
+type Predicate = (row: RowValue) => boolean;
+/**
+ * Attempt to translate a TanStack DB expression into an ArrowBase
+ * predicate. Returns `null` if the expression is not pushable.
+ */
+declare function pushDown(expr: BasicExpression<boolean> | undefined, knownColumns: ReadonlySet<string>): Predicate | null;
+
+type DeltaType = 'enter' | 'exit' | 'update';
+type DeltaEvent<TRow extends object = Record<string, unknown>, TKey extends string | number = string | number> = {
+    type: 'enter';
+    key: TKey;
+    value: TRow;
+    metadata?: Record<string, unknown>;
+} | {
+    type: 'exit';
+    key: TKey;
+    value: TRow;
+    metadata?: Record<string, unknown>;
+} | {
+    type: 'update';
+    key: TKey;
+    value: TRow;
+    previousValue: TRow;
+    metadata?: Record<string, unknown>;
+};
+interface EffectContext {
+    effectId: string;
+    signal: AbortSignal;
+}
+type EffectQueryInput = ((q: InitialQueryBuilder) => QueryBuilder<any>) | QueryBuilder<any>;
+type EffectEventHandler<TRow extends object = Record<string, unknown>, TKey extends string | number = string | number> = (event: DeltaEvent<TRow, TKey>, ctx: EffectContext) => void | Promise<void>;
+type EffectBatchHandler<TRow extends object = Record<string, unknown>, TKey extends string | number = string | number> = (events: Array<DeltaEvent<TRow, TKey>>, ctx: EffectContext) => void | Promise<void>;
+interface EffectConfig<TRow extends object = Record<string, unknown>, TKey extends string | number = string | number> {
+    id?: string;
+    query: EffectQueryInput;
+    onEnter?: EffectEventHandler<TRow, TKey>;
+    onUpdate?: EffectEventHandler<TRow, TKey>;
+    onExit?: EffectEventHandler<TRow, TKey>;
+    onBatch?: EffectBatchHandler<TRow, TKey>;
+    onError?: (error: Error, event: DeltaEvent<TRow, TKey>) => void;
+    onSourceError?: (error: Error) => void;
+    skipInitial?: boolean;
+}
+interface Effect {
+    dispose: () => Promise<void>;
+    readonly disposed: boolean;
+}
+declare function createEffect<TRow extends object = Record<string, unknown>, TKey extends string | number = string | number>(config: EffectConfig<TRow, TKey>): Effect;
+
+declare const DEFAULT_COMPARE_OPTIONS: {
+    readonly direction: "asc";
+    readonly nulls: "first";
+    readonly stringSort: "locale";
+};
+declare function isTemporal(value: unknown): boolean;
+declare function deepEquals(a: unknown, b: unknown): boolean;
+
+declare class SortedMap<TKey extends string | number, TValue> {
+    private comparator?;
+    private map;
+    private sortedKeys;
+    constructor(comparator?: ((a: TValue, b: TValue) => number) | undefined);
+    private indexOf;
+    set(key: TKey, value: TValue): this;
+    get(key: TKey): TValue | undefined;
+    delete(key: TKey): boolean;
+    has(key: TKey): boolean;
+    clear(): void;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<[TKey, TValue]>;
+    entries(): IterableIterator<[TKey, TValue]>;
+    keys(): IterableIterator<TKey>;
+    values(): IterableIterator<TValue>;
+    forEach(callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void): void;
+}
+
+interface ChangeTracker<T extends object> {
+    originalObject: T;
+    modified: boolean;
+    copy_: T;
+    proxyCount: number;
+    assigned_: Record<string | symbol, boolean>;
+    parent?: {
+        tracker: ChangeTracker<Record<string | symbol, unknown>>;
+        prop: string | symbol;
+    } | undefined;
+    target: T;
+}
+declare function createChangeProxy<T extends Record<string | symbol, any | undefined>>(target: T, parent?: {
+    tracker: ChangeTracker<Record<string | symbol, unknown>>;
+    prop: string | symbol;
+}): {
+    proxy: T;
+    getChanges: () => Record<string | symbol, any>;
+};
+declare function createArrayChangeProxy<T extends object>(targets: Array<T>): {
+    proxies: Array<T>;
+    getChanges: () => Array<Record<string | symbol, unknown>>;
+};
+declare function withChangeTracking<T extends object>(target: T, callback: (proxy: T) => void): Record<string | symbol, unknown>;
+declare function withArrayChangeTracking<T extends object>(targets: Array<T>, callback: (proxies: Array<T>) => void): Array<Record<string | symbol, unknown>>;
+
+type VirtualOrigin = 'local' | 'remote';
+interface VirtualRowProps<TKey extends string | number = string | number> {
+    readonly $synced: boolean;
+    readonly $origin: VirtualOrigin;
+    readonly $key: TKey;
+    readonly $collectionId: string;
+}
+type WithVirtualProps<T extends object, TKey extends string | number = string | number> = T & VirtualRowProps<TKey>;
+type WithoutVirtualProps<T> = Omit<T, keyof VirtualRowProps>;
+declare const VIRTUAL_PROP_NAMES: readonly ["$synced", "$origin", "$key", "$collectionId"];
+declare function hasVirtualProps(value: unknown): value is VirtualRowProps<string | number>;
+declare function createVirtualProps<TKey extends string | number>(key: TKey, collectionId: string, isSynced: boolean, origin: VirtualOrigin): VirtualRowProps<TKey>;
+declare function enrichRowWithVirtualProps<T extends object, TKey extends string | number>(row: T, key: TKey, collectionId: string, computeSynced: () => boolean, computeOrigin: () => VirtualOrigin): WithVirtualProps<T, TKey>;
+declare function computeAggregateVirtualProps<TKey extends string | number>(rows: Array<Partial<VirtualRowProps<string | number>>>, groupKey: TKey, collectionId: string): VirtualRowProps<TKey>;
+declare function isVirtualPropName(name: string): boolean;
+declare function hasVirtualPropPath(path: Array<string>): boolean;
+
+/** Error types thrown by ArrowBase and TanStack-compatible surfaces. */
+declare class ArrowBaseError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+declare class TanStackDBError extends ArrowBaseError {
+    constructor(message: string, code?: string);
+}
+declare class NonRetriableError extends TanStackDBError {
+    constructor(message: string);
+}
+interface SchemaIssue {
+    message: string;
+    path: unknown;
+}
+declare class SchemaValidationError extends TanStackDBError {
+    readonly type: 'insert' | 'update';
+    readonly issues: Array<SchemaIssue>;
+    constructor(type: 'insert' | 'update', issues: Array<SchemaIssue>, message?: string);
+}
+declare class DuplicateDbInstanceError extends TanStackDBError {
+    constructor();
+}
+declare class SchemaError extends ArrowBaseError {
+    constructor(message: string);
+}
+declare class AllocatorError extends ArrowBaseError {
+    constructor(message: string);
+}
+declare class OutOfSpaceError extends AllocatorError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends ArrowBaseError {
+    constructor(message: string);
+}
+declare class UndoError extends ArrowBaseError {
+    constructor(message: string);
+}
+declare class ValidationError extends ArrowBaseError {
+    constructor(message: string);
+}
+declare class PersistenceError extends ArrowBaseError {
+    constructor(message: string);
+}
+declare class CollectionConfigurationError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class CollectionRequiresConfigError extends CollectionConfigurationError {
+    constructor();
+}
+declare class CollectionRequiresSyncConfigError extends CollectionConfigurationError {
+    constructor();
+}
+declare class InvalidSchemaError extends CollectionConfigurationError {
+    constructor();
+}
+declare class SchemaMustBeSynchronousError extends CollectionConfigurationError {
+    constructor();
+}
+declare class CollectionStateError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class CollectionInErrorStateError extends CollectionStateError {
+    constructor(operation: string, collectionId: string);
+}
+declare class InvalidCollectionStatusTransitionError extends CollectionStateError {
+    constructor(from: string, to: string, collectionId: string);
+}
+declare class CollectionIsInErrorStateError extends CollectionStateError {
+    constructor();
+}
+declare class NegativeActiveSubscribersError extends CollectionStateError {
+    constructor();
+}
+declare class CollectionOperationError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class UndefinedKeyError extends CollectionOperationError {
+    constructor(item: unknown);
+}
+declare class InvalidKeyError extends CollectionOperationError {
+    constructor(key: unknown, item: unknown);
+}
+declare class DuplicateKeyError extends CollectionOperationError {
+    constructor(key: string | number);
+}
+declare class DuplicateKeySyncError extends CollectionOperationError {
+    constructor(key: string | number, collectionId: string, options?: {
+        hasCustomGetKey?: boolean;
+        hasDistinct?: boolean;
+        hasJoins?: boolean;
+    });
+}
+declare class MissingUpdateArgumentError extends CollectionOperationError {
+    constructor();
+}
+declare class NoKeysPassedToUpdateError extends CollectionOperationError {
+    constructor();
+}
+declare class UpdateKeyNotFoundError extends CollectionOperationError {
+    constructor(key: string | number);
+}
+declare class KeyUpdateNotAllowedError extends CollectionOperationError {
+    constructor(originalKey: string | number, newKey: string | number);
+}
+declare class NoKeysPassedToDeleteError extends CollectionOperationError {
+    constructor();
+}
+declare class DeleteKeyNotFoundError extends CollectionOperationError {
+    constructor(key: string | number);
+}
+declare class MissingHandlerError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class MissingInsertHandlerError extends MissingHandlerError {
+    constructor();
+}
+declare class MissingUpdateHandlerError extends MissingHandlerError {
+    constructor();
+}
+declare class MissingDeleteHandlerError extends MissingHandlerError {
+    constructor();
+}
+declare class TransactionError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class MissingMutationFunctionError extends TransactionError {
+    constructor();
+}
+declare class OnMutateMustBeSynchronousError extends TransactionError {
+    constructor();
+}
+declare class TransactionNotPendingMutateError extends TransactionError {
+    constructor();
+}
+declare class TransactionAlreadyCompletedRollbackError extends TransactionError {
+    constructor();
+}
+declare class TransactionNotPendingCommitError extends TransactionError {
+    constructor();
+}
+declare class NoPendingSyncTransactionWriteError extends TransactionError {
+    constructor();
+}
+declare class SyncTransactionAlreadyCommittedWriteError extends TransactionError {
+    constructor();
+}
+declare class NoPendingSyncTransactionCommitError extends TransactionError {
+    constructor();
+}
+declare class SyncTransactionAlreadyCommittedError extends TransactionError {
+    constructor();
+}
+declare class QueryBuilderError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class OnlyOneSourceAllowedError extends QueryBuilderError {
+    constructor(context: string);
+}
+declare class SubQueryMustHaveFromClauseError extends QueryBuilderError {
+    constructor(context: string);
+}
+declare class InvalidSourceError extends QueryBuilderError {
+    constructor(alias: string);
+}
+declare class InvalidSourceTypeError extends QueryBuilderError {
+    constructor(context: string, type: string);
+}
+declare class JoinConditionMustBeEqualityError extends QueryBuilderError {
+    constructor();
+}
+declare class QueryMustHaveFromClauseError extends QueryBuilderError {
+    constructor();
+}
+declare class InvalidWhereExpressionError extends QueryBuilderError {
+    constructor(valueType: string);
+}
+declare class QueryCompilationError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class UnsafeAliasPathError extends QueryCompilationError {
+    constructor(segment: string);
+}
+declare class DistinctRequiresSelectError extends QueryCompilationError {
+    constructor();
+}
+declare class FnSelectWithGroupByError extends QueryCompilationError {
+    constructor();
+}
+declare class UnsupportedRootScalarSelectError extends QueryCompilationError {
+    constructor();
+}
+declare class HavingRequiresGroupByError extends QueryCompilationError {
+    constructor();
+}
+declare class LimitOffsetRequireOrderByError extends QueryCompilationError {
+    constructor();
+}
+declare class CollectionInputNotFoundError extends QueryCompilationError {
+    constructor(alias: string, collectionId?: string, availableKeys?: Array<string>);
+}
+declare class DuplicateAliasInSubqueryError extends QueryCompilationError {
+    constructor(alias: string, parentAliases: Array<string>);
+}
+declare class UnsupportedFromTypeError extends QueryCompilationError {
+    constructor(type: string);
+}
+declare class UnknownExpressionTypeError extends QueryCompilationError {
+    constructor(type: string);
+}
+declare class EmptyReferencePathError extends QueryCompilationError {
+    constructor();
+}
+declare class UnknownFunctionError extends QueryCompilationError {
+    constructor(functionName: string);
+}
+declare class JoinCollectionNotFoundError extends QueryCompilationError {
+    constructor(collectionId: string);
+}
+declare class JoinError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class UnsupportedJoinTypeError extends JoinError {
+    constructor(joinType: string);
+}
+declare class InvalidJoinConditionSameSourceError extends JoinError {
+    constructor(sourceAlias: string);
+}
+declare class InvalidJoinConditionSourceMismatchError extends JoinError {
+    constructor();
+}
+declare class InvalidJoinConditionLeftSourceError extends JoinError {
+    constructor(sourceAlias: string);
+}
+declare class InvalidJoinConditionRightSourceError extends JoinError {
+    constructor(sourceAlias: string);
+}
+declare class InvalidJoinCondition extends JoinError {
+    constructor();
+}
+declare class UnsupportedJoinSourceTypeError extends JoinError {
+    constructor(type: string);
+}
+declare class GroupByError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class NonAggregateExpressionNotInGroupByError extends GroupByError {
+    constructor(alias: string);
+}
+declare class UnsupportedAggregateFunctionError extends GroupByError {
+    constructor(functionName: string);
+}
+declare class AggregateFunctionNotInSelectError extends GroupByError {
+    constructor(functionName: string);
+}
+declare class UnknownHavingExpressionTypeError extends GroupByError {
+    constructor(type: string);
+}
+declare class StorageError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class SerializationError extends StorageError {
+    constructor(operation: string, originalError: unknown);
+}
+declare class LocalStorageCollectionError extends StorageError {
+    constructor(message: string);
+}
+declare class StorageKeyRequiredError extends LocalStorageCollectionError {
+    constructor();
+}
+declare class InvalidStorageDataFormatError extends LocalStorageCollectionError {
+    constructor(storageKey: string, key: string);
+}
+declare class InvalidStorageObjectFormatError extends LocalStorageCollectionError {
+    constructor(storageKey: string);
+}
+declare class SyncCleanupError extends TanStackDBError {
+    constructor(collectionId: string, error: unknown);
+}
+declare class QueryOptimizerError extends TanStackDBError {
+    constructor(message: string);
+}
+declare class CannotCombineEmptyExpressionListError extends QueryOptimizerError {
+    constructor();
+}
+declare class WhereClauseConversionError extends QueryOptimizerError {
+    constructor(collectionId: string, alias: string);
+}
+declare class SubscriptionNotFoundError extends QueryCompilationError {
+    constructor(resolvedAlias: string, originalAlias: string, collectionId: string, availableAliases: Array<string>);
+}
+declare class AggregateNotSupportedError extends QueryCompilationError {
+    constructor();
+}
+declare class MissingAliasInputsError extends QueryCompilationError {
+    constructor(missingAliases: Array<string>);
+}
+declare class SetWindowRequiresOrderByError extends QueryCompilationError {
+    constructor();
+}
+
+export { ARROW_ALIGN, Aggregate, AggregateFunctionNotInSelectError, AggregateNotSupportedError, AllocatorError, type ApplyJoinOptionalityToMergedSchema, ArrowBaseError, BBox, BTreeIndex, type BTreeIndexOptions, RangeQueryOptions as BTreeRangeQueryOptions, BaseIndex, BaseQueryBuilder, BasicExpression$1 as BasicExpression, BasicIndex, type BasicIndexOptions, CannotCombineEmptyExpressionListError, ChangeLog, type ChangeLogOptions, ChangeMessage, type ChangeTracker, Collection, CollectionConfigurationError, type CollectionDescription, Collection as CollectionImpl, CollectionInErrorStateError, CollectionInputNotFoundError, CollectionIsInErrorStateError, CollectionOperationError, CollectionRequiresConfigError, CollectionRequiresSyncConfigError, CollectionStateError, CollectionStatus, CollectionSubscription, type ColumnDescription, ColumnTypeName, CompareOptions, type CompilationResult, type CompiledExpression, CompiledSchema, ConcatToArrayWrapper, type Context, type ContextSchema, CreateCollectionConfig, CreateOptimisticActionsOptions, DEFAULT_COMPARE_OPTIONS, DebounceStrategy, DebounceStrategyOptions, DeduplicatedLoadSubset, DeduplicatedLoadSubset as DeduplicatedLoadSubsetType, DeleteKeyNotFoundError, DeleteMutationFn, Delta, type DeltaEvent, type DeltaType, type DepSet, DistinctRequiresSelectError, DuplicateAliasInSubqueryError, DuplicateDbInstanceError, DuplicateKeyError, DuplicateKeySyncError, type Effect, type EffectConfig, type EffectContext, type EffectQueryInput, type EmptyContext, EmptyReferencePathError, type ExtractContext, type FieldPath, FnSelectWithGroupByError, type FunctionalHavingRow, type GetResult, GroupBy, type GroupByCallback, GroupByError, Having, HavingRequiresGroupByError, type IncludesCompilationResult, IncludesMaterialization, IncludesSubquery, IndexConstructor, type IndexDevModeConfig, type IndexInfo, IndexInterface, IndexOperation, IndexOperation as IndexOperationType, IndexStats, type IndexSuggestion, type InferCollectionType, type InferResultType, type InitialQueryBuilder, InsertMutationFn, InvalidCollectionStatusTransitionError, InvalidJoinCondition, InvalidJoinConditionLeftSourceError, InvalidJoinConditionRightSourceError, InvalidJoinConditionSameSourceError, InvalidJoinConditionSourceMismatchError, InvalidKeyError, InvalidSchemaError, InvalidSourceError, InvalidSourceTypeError, InvalidStorageDataFormatError, InvalidStorageObjectFormatError, InvalidWhereExpressionError, JoinCollectionNotFoundError, JoinConditionMustBeEqualityError, JoinError, JoinExecutor, type JoinOn, type JoinOnCallback, JoinQuery, type JoinSpec, type JoinType, type JoinedQuerySnapshot, KeyUpdateNotAllowedError, LIVE_QUERY_INTERNAL, LimitOffsetRequireOrderByError, LiveQueryCollection, type LiveQueryCollectionConfig, type LiveQueryCollectionOptions, type LiveQueryCollectionUtils, LiveQueryController, type LiveQueryInternalUtils, type LiveQueryKey, type LiveQueryRow, type LiveQueryStatusFlags, LoadSubsetOptions, LocalOnlyCollectionConfig, LocalOnlyCollectionOptionsResult, LocalStorageCollectionConfig, LocalStorageCollectionError, LocalStorageCollectionOptionsResult, MaterializeWrapper, MemorySyncAdapter, type MergeContextForJoinCallback, type MergeContextWithJoinType, MissingAliasInputsError, MissingDeleteHandlerError, MissingHandlerError, MissingInsertHandlerError, MissingMutationFunctionError, MissingUpdateArgumentError, MissingUpdateHandlerError, NegativeActiveSubscribersError, NoKeysPassedToDeleteError, NoKeysPassedToUpdateError, NoPendingSyncTransactionCommitError, NoPendingSyncTransactionWriteError, NonAggregateExpressionNotInGroupByError, NonRetriableError, NotFoundError, OnMutateMustBeSynchronousError, OnlyOneSourceAllowedError, OperatorName, type OptimizationResult, OrderBy, type OrderByCallback, OrderByDirection, type OrderByOptions, OrderSpec, OutOfSpaceError, PacedMutationsConfig, type ParseWhereOptions, type ParsedOrderBy, PersistenceError, Point, Predicate$1 as Predicate, type Prettify, PropRef, type Predicate as PushDownPredicate, Query, type QueryBuilder, QueryBuilderError, QueryCompilationError, QueryIR, QueryMustHaveFromClauseError, type QueryOnceConfig, type QueryOnceQuery, type QueryOnceResult, QueryOptimizerError, type QueryPattern, type QueryResult, type QuerySource, QueueStrategy, QueueStrategyOptions, RangeQueryOptions, type RefsForContext, type ResultRow, type ResultTypeFromSelect, type ResyncListener, ReverseIndex, RootRefProxy, RowIndex, RowValue, SNAPSHOT_ALIGN, SNAPSHOT_FORMAT_VERSION, SNAPSHOT_MAGIC, SchemaError, type SchemaFromSource, SchemaMustBeSynchronousError, SchemaValidationError, Segment, Select, type SelectObject, SerializationError, SetWindowRequiresOrderByError, SharedDeltaLog, type SimpleComparison, SingleRowRefProxy, type SnapshotColumnMeta, type SnapshotHeaderJson, SnapshotRowDecoder, SortDir, SortedMap, type Source, type SourceRecord, StorageError, StorageKeyRequiredError, StringCollationConfig, SubQueryMustHaveFromClauseError, SubscribeChangesOptions, SubscriptionNotFoundError, SyncAdapter, SyncCleanupError, SyncConfig, SyncTransactionAlreadyCommittedError, SyncTransactionAlreadyCommittedWriteError, TOMBSTONE_ROW, TanStackDBError, ThrottleStrategy, ThrottleStrategyOptions, ToArrayWrapper, TransactionAlreadyCompletedRollbackError, TransactionError, TransactionNotPendingCommitError, TransactionNotPendingMutateError, UndefinedKeyError, UndoError, type UndoOp, type UndoRecord, UndoRing, UnknownExpressionTypeError, UnknownFunctionError, UnknownHavingExpressionTypeError, UnsafeAliasPathError, UnsupportedAggregateFunctionError, UnsupportedFromTypeError, UnsupportedJoinSourceTypeError, UnsupportedJoinTypeError, UnsupportedRootScalarSelectError, UpdateKeyNotFoundError, UpdateMutationFn, UtilsRecord, VIRTUAL_PROP_NAMES, ValidationError, type VirtualOrigin, type VirtualRowProps, Where, type WhereCallback, WhereClauseConversionError, type WindowOptions, type WithResult, type WithVirtualProps, type WithoutVirtualProps, alignSnapshot, alignUp, applyDeltas, bboxIntersects, bboxWithin, buildQuery, clearQueryPatterns, compileExpression, compileQuery, compileSingleRowExpression, computeAggregateVirtualProps, configureIndexDevMode, contains, createArrayChangeProxy, createChangeProxy, createCollection, createEffect, createLiveQueryCollection, createOptimisticAction, createPacedMutations, createSegment, createVirtualProps, debounceStrategy, deepEquals, describeCollection, dwithin, enrichRowWithVirtualProps, exportSnapshot, extractFieldPath, extractSimpleComparisons, extractValue, findIndexForField, getCollectionMetadata, getIndexDevModeConfig, getLiveQueryStatusFlags, getQueryIR, getQueryPatterns, hasVirtualPropPath, hasVirtualProps, importSnapshot, isCollection, isDevModeEnabled, isLimitSubset, isOffsetLimitSubset, isOrderBySubset, isPredicateSubset, isSingleResultCollection, isTemporal, isVirtualPropName, isWhereSubset, join, liveQueryCollectionOptions, localOnlyCollectionOptions, localStorageCollectionOptions, minusWherePredicates, optimizeExpressionWithIndexes, parseLoadSubsetOptions, parseOrderByExpression, parseWhereExpression, pushDown, queryOnce, queueStrategy, readSnapshotHeader, runCollection, runJoin, runLive, safeRandomUUID, throttleStrategy, toBooleanPredicate, trackQuery, trackRow, unionWherePredicates, walkExpression, withArrayChangeTracking, withChangeTracking, within };