@omegup/msync 0.1.27 → 0.1.28

package/index.d.ts

@@ -1,13 +1,684 @@
-export * from './lib/accumulators';
-export * from './lib/aggregate';
-export * from './lib/boot';
-export * from './lib/expression';
-export * from './lib/field';
-export * from './lib/update';
-export * from './lib/machine';
-export * from './lib/predicate';
-export * from './lib/query';
-export * from './lib/utils';
-export * from './lib/types/extern';
-export * from './types/extern';
-export { enablePreAndPostImages, prepare, makeCol } from './test/mongodb';
+import { Timestamp, Filter, UpdateFilter, BSON, Db, Collection, IndexSpecification, CreateIndexesOptions, OptionalUnlessRequiredId, MongoClient as MongoClient$1 } from 'mongodb';
+export { Collection, Timestamp } from 'mongodb';
+
+declare const Type: unique symbol;
+
+type U = undefined;
+type N = null | U;
+type jsonPrim = number | null | string | boolean | Timestamp | Date;
+type notObj = jsonPrim | U;
+type notArr = notObj | O;
+type jsonItem = unknown;
+type rawItem = jsonPrim | raw | U;
+type Undef<I extends N> = I | (I extends never ? I : notObj);
+declare const object: unique symbol;
+declare const array$1: unique symbol;
+type A = {
+    [Type]: typeof array$1;
+};
+type Arr<T, N extends number = number> = A & {
+    readonly [_ in N]: T;
+};
+type Obj = {
+    [Type]: typeof object;
+};
+type O<T = unknown> = Obj & T;
+type RORec<K extends keyof never, T = unknown> = {
+    readonly [P in K]: T;
+};
+type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
+type O2 = readonly [O, O];
+type O3 = readonly [O, O, O];
+type ID = {
+    readonly _id: string;
+};
+type doc = O & ID;
+interface RawObj {
+    readonly [_: string]: rawItem | U;
+}
+type raw = readonly rawItem[] | RawObj;
+type StrKey<T> = string & keyof T;
+type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
+type AsLiteral<T extends keyof any | boolean, V = NoUnion<T>> = T extends keyof any ? {} extends {
+    [K in T]: 1;
+} ? never : V : V;
+type NoUnion<T, V = T> = T extends unknown ? ([V] extends [T] ? T : never) : never;
+
+type HasJob = {
+    job: object | undefined;
+};
+type Runner<T, Info extends HasJob> = Iterator<T, Info>;
+type NextFrame<T, Info> = PromiseLike<Frame<T, Info>>;
+type Frame<T, Info> = {
+    data: T;
+    info: Info;
+    cont: Iterator<T, Info>;
+};
+type IteratorResult<out T, out Info> = {
+    next: NextFrame<T, Info>;
+    stop: Iterator<T, Info>;
+    clear: () => Promise<unknown>;
+};
+type Iterator<out T, out Info> = () => IteratorResult<T, Info>;
+
+declare const PredicateRaw: unique symbol;
+type PredicateRaw = RawObj & {
+    [Type]?(x: typeof PredicateRaw): void;
+};
+declare const Predicate: unique symbol;
+interface Predicate<in V> {
+    [Type]?(x: typeof Predicate, _: V): void;
+    raw: PredicateRaw;
+}
+
+declare class Field<in R, out V, in C = unknown> {
+    private field;
+    private raw;
+    private concat;
+    has<R extends O>(this: Field<R, V>, p: Predicate<V>): Query<R, C>;
+    has<R extends O, V>(this: Field<R, Arr<V>>, p: Predicate<V>): Query<R, C>;
+    private constructor();
+    static root: <T extends O>() => Field<T, T, unknown>;
+    static ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;
+    of<V, K extends keyof V, _ extends 0 = 0>(this: Field<R, Arr<V>, C>, k: AsLiteral<K>): Field<R, Arr<V[K]>, C>;
+    of<V, K extends keyof V, _ extends 1 = 1>(this: Field<R, O<V>, C>, k: K): Field<R, V[K], C>;
+    of<V, K extends keyof V, I extends N = never, _ extends 2 = 2>(this: Field<R, Arr<V> | Undef<I>, C>, k: K): Field<R, Arr<V[K]> | I, C>;
+    of<V, K extends keyof V, I extends N = never, _ extends 3 = 3>(this: Field<R, O<V> | Undef<I>, C>, k: K): Field<R, V[K] | I, C>;
+    with<V, W, C2 = unknown, _ extends 0 = 0>(this: Field<R, O<V>, C>, k: Field<O<V>, W, C2>): Field<R, W, C & C2>;
+    with<V, W, C2 = unknown, _ extends 1 = 1>(this: Field<R, Arr<V>, C>, k: Field<O<V>, Arr<W> | O<W>, C2>): Field<R, Arr<W>, C & C2>;
+    with<V, W, I extends N = never, C2 = unknown, _ extends 2 = 2>(this: Field<R, O<V> | Undef<I>, C>, k: Field<O<V>, W, C2>): Field<R, W | I, C & C2>;
+    with<V, W, I extends N = never, C2 = unknown, _ extends 3 = 3>(this: Field<R, Arr<V> | Undef<I>, C>, k: Field<O<V>, Arr<W> | O<W>, C2>): Field<R, Arr<W> | I, C & C2>;
+    str(this: Field<R, V>): string;
+    private exprRaw;
+    expr<R, V, C = unknown>(this: Field<R, V, C>): Expr<V, R, C>;
+}
+declare const root: <T extends O>() => Field<T, T, unknown>;
+declare const ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;
+
+declare const QueryRaw: unique symbol;
+type QueryRaw<T, C = unknown> = RawObj & {
+    [Type]?(x: typeof QueryRaw, y: T, c: C): void;
+};
+declare const Query: unique symbol;
+type Query<in T extends O, in C = unknown> = {
+    [Type]?(x: typeof Query, y: T, c: C): void;
+    raw: <DeltaT extends O>(f: Field<DeltaT, T>) => QueryRaw<DeltaT, C>;
+};
+
+declare const RawStage$1: unique symbol;
+type RawArr = readonly RawObj[];
+interface RawStages<out Q, in S extends Q, out R extends Q, in C = unknown, out M = number> extends RawArr {
+    [Type]?(_: typeof RawStage$1, source: S, ctx: C, q: Q): readonly [typeof RawStage$1, R, M, Q];
+}
+type FRawStages<out Q, in S extends Q & O, out R extends Q & O, in C = unknown, out M extends number = number> = <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, Q & O>, App<F, S>, App<F, R>, C, M>;
+type DeltaStages<out Q, in S extends Q & O, out R extends Q & O, in C = unknown> = {
+    delta: RawStages<unknown, Delta<S>, Delta<R>, C>;
+    raw: FRawStages<Q, S, R, C>;
+};
+type LinStages<out Q, in S extends Q, out R extends Q, in C = unknown> = {
+    lin: RawStages<Q, S, R, C, 1>;
+};
+type TStages<in out S, out Q, in out B extends Q, out R extends Q, M extends number = number> = {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, S, B, unknown, M>;
+    exec: RawStages<Q, B, R, unknown, M>;
+};
+type Stages<out Q, out R extends Q, out SDom> = <E>(consume: <S extends SDom, B extends Q>(value: TStages<S, Q, B, R>) => E) => E;
+type Actions<W> = {
+    updateMany: [Filter<W>, UpdateFilter<W> | BSON.Document[]];
+    deleteMany: [Filter<W>];
+};
+type TeardownRecord<W, M extends keyof Actions<W>> = {
+    collection: WriteonlyCollection<W>;
+    method: M;
+    params: Actions<W>[M];
+};
+type StreamRunnerParam<in V, out Result> = {
+    raw: (first: boolean) => RawStages<unknown, V, Result>;
+    teardown: <R>(consume: <W, M extends keyof Actions<W>>(x: TeardownRecord<W, M>) => R) => R;
+};
+type StreamRunner<out V> = <Result>(input: StreamRunnerParam<V, Result>, setup?: () => Promise<void>) => Runner<readonly Result[], HasJob>;
+type SimpleStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<V>;
+};
+type SnapshotStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<Delta<V>>;
+    readonly stages: Stages<Before<Q>, Before<V>, UBefore<Q>>;
+};
+type Stream<out Q extends O, in out T extends Q, in out F extends HKT<[O, O]>, in out G extends HKT<[O, O, O]>> = <Q2 extends O, Result extends Q2>(input: App<G, [Q2 | T, T, Result]>) => App<F, [Q | Q2, Result]>;
+type TS = {
+    readonly touchedAt: Timestamp;
+};
+type IsDeleted = {
+    readonly deletedAt: Timestamp;
+};
+type DDel = IsDeleted & ID & TS;
+type Del = O<DDel>;
+type DeletedAt = {
+    readonly deletedAt?: Timestamp | null | undefined;
+};
+type D = O<DeletedAt & ID>;
+type Model = D & TS;
+type BA = 'before' | 'after';
+type PreDelta<T, K extends BA = BA, E = unknown> = Rec<K, T> & E;
+type Delta<T, K extends BA = BA, E = ID> = PreDelta<T | null, K, E>;
+type Before<T> = PreDelta<T, 'before'>;
+type UBefore<T> = O & Partial<Delta<T | null, 'before'>>;
+type SnapshotStream<out Q extends O, in out T extends Q> = <Q2 extends O, Result extends Q2>(input: DeltaStages<Q2 | T, T, Result>) => SnapshotStreamExecutionResult<Q | Q2, Result>;
+
+declare const ExprRaw: unique symbol;
+type ExprRaw<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof ExprRaw): void;
+    [ExprRaw]?(doc: Doc, ctx: Ctx): T;
+    get: () => rawItem;
+};
+declare const Expr: unique symbol;
+type Expr<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof Expr): void;
+    [Expr]?(doc: Doc, ctx: Ctx): T;
+    raw: {
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, Doc | Undef<I>, C>): ExprRaw<T | I, DeltaD, Ctx & C>;
+    };
+};
+type BoolExpr<in D1, in D2, in Ctx = unknown> = {
+    [Type]?(x: typeof Expr): void;
+    [Expr](doc: D1, ctx: Ctx): true;
+    [Expr](doc: D2, ctx: Ctx): false;
+    raw: {
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D1 | D2 | Undef<I>, C>): ExprRaw<boolean, DeltaD, Ctx & C>;
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D1 | Undef<I>, C>): ExprRaw<true, DeltaD, Ctx & C>;
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D2 | Undef<I>, C>): ExprRaw<false, DeltaD, Ctx & C>;
+    };
+};
+
+type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
+type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
+type MapO<T, F extends HKT<StrKey<T>>> = MapOPart<T, F> & {
+    readonly [P: string]: readonly [StrKey<T>, unknown];
+};
+type MapOPart<T, F extends HKT<StrKey<T>>, K extends keyof T = StrKey<T>> = {
+    readonly [P in K]: readonly [P, App<F, P & string>];
+};
+type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
+interface MappedHKT<T, F extends HKT<T[StrKey<T>]>> extends HKT<StrKey<T>> {
+    readonly out: App<F, T[I<StrKey<T>, this>]>;
+}
+interface MergeHKT<T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, No extends keyof V = never> extends HKT<StrKey<V & Omit<T, No>>> {
+    readonly out: I<StrKey<V & Omit<T, No>>, this> extends StrKey<V> ? App<F2, I<StrKey<V>, this>> : App<F1, I<StrKey<Omit<T, No>>, this>>;
+}
+
+declare const AccumulatorRaw: unique symbol;
+interface AccumulatorRaw<in Doc, out T, in C = unknown> extends RawObj {
+    [Type](_: typeof AccumulatorRaw, source: Doc, ctx: C): readonly [typeof AccumulatorRaw, T];
+}
+interface AccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: Accumulator<T, I<unknown, this>, C>;
+}
+type Accumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, AccumulatorHKT<T, C>>;
+interface DeltaAccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: DeltaAccumulator<T, I<unknown, this>, C>;
+}
+type DeltaAccumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, DeltaAccumulatorHKT<T, C>>;
+declare const Accumulator: unique symbol;
+type Accumulator<in Doc, out T, in Ctx = unknown> = {
+    [Type]?(_: typeof Accumulator): typeof Accumulator;
+    raw: {
+        <DeltaD extends O, I extends U>(f: Field<DeltaD, Doc | Undef<I>>): AccumulatorRaw<T | I, DeltaD, Ctx>;
+    };
+};
+type Part<Doc> = Rec<'v', Doc> & RORec<'old', boolean>;
+type DeltaAccumulator<in out Doc, in out T, in out Ctx = unknown> = {
+    group: Accumulator<Part<Doc>, T, Ctx>;
+    merge: <D, C = Ctx>(a: Expr<T | N, D, C>, b: Expr<T, D, C>) => Expr<T, D, C>;
+};
+
+declare const concat: {
+    <D, C>(...expr: Expr<string, D, C>[]): Expr<string, D, C>;
+    <D, C>(...expr: Expr<string | N, D, C>[]): Expr<string | N, D, C>;
+};
+declare const regex: <D, C>(expr: Expr<string, D, C>, regex: Expr<string, D, C>, options?: Expr<string, D, C>) => Expr<boolean, D, C>;
+declare const str: <D, C>(expr: Expr<unknown, D, C>) => Expr<string, D, C>;
+declare const toInt: <D, C>(expr: Expr<unknown, D, C>) => Expr<number, D, C>;
+declare const fieldM: <M extends RORec<Dom, Ref>, T extends RORec<Ref, unknown>, D, Dom extends string = StrKey<M>, Ref extends string = StrKey<T>, C = unknown>(expr: { readonly [K in Ref]: Expr<T[K], D, C>; }, m: Pick<M, Dom>) => Expr<O<{ readonly [K in Dom]: T[M[K]]; }>, D, C>;
+type Exprs<out T, in D, in C = unknown> = {
+    readonly [K in StrKey<T>]: Expr<T[K], D, C>;
+};
+declare const mergeExact: <T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>, E = unknown>(exprsExact1: Exact<Omit<T1, keyof T2>, F>, exprsExact2: Exact<T2, F>) => Exact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, F>;
+type MergeMapOArgs<T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>> = readonly [MapO<Omit<T1, StrKey<T2>>, F1>, MapO<T2, F2>];
+declare const mergeExact0: <T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>, E = unknown>(exprsExact1: MapO<Omit<T1, StrKey<T2>>, F1>, exprsExact2: MapO<T2, F2>) => MapO<T2 & Omit<T1, StrKey<T2>> & Pick<E, symbol & keyof E>, MergeHKT<T1, T2, F1, F2, StrKey<T2>>>;
+declare const mergeExpr: <T1, T2, D, C = unknown, E = unknown>(exprs_0: Exact<Omit<T1, keyof T2>, ExprHKT<D, C, IdHKT<unknown>>>, exprs_1: Exact<T2, ExprHKT<D, C, IdHKT<unknown>>>) => ExprsExact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, D, C>;
+type ExprsPart<T, D, C> = ExactPart<T, ExprHKT<D, C>>;
+interface ExprHKT<D, C = unknown, F extends HKT = IdHKT> extends HKT<unknown> {
+    readonly out: Expr<App<F, I<unknown, this>>, D, C>;
+}
+type ExprsExact<T, D, C = unknown, F extends HKT = IdHKT> = Exact<T, ExprHKT<D, C, F>>;
+interface ExprsExactHKT<E, D, C = unknown, F extends HKT = IdHKT> extends HKT {
+    readonly out: ExprsExact<E & I<unknown, this>, D, C, F>;
+}
+declare const pair: <T, D, C, P extends StrKey<T>>(k: P, v: Expr<T[P], D, C>) => ExprsExact<T, D, C>[P];
+declare const fieldF: <F extends HKT>() => <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C, F>) => Expr<O<{ [K in keyof T]: App<F, T[K]>; }>, D, C>;
+declare const field: <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C>) => Expr<O<T>, D, C>;
+
+interface HKT<in Dom = unknown, out Im = unknown> {
+    readonly in: (x: Dom) => void;
+    readonly out: Im;
+}
+type App<F extends HKT<X>, X> = (F & {
+    readonly in: (x: X) => void;
+})['out'];
+type I<Dom, F extends HKT<Dom>> = F['in'] extends (x: infer X extends Dom) => void ? X : never;
+interface IdHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: I<Dom, this>;
+}
+type AppMap<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = readonly App<F, Dom>[] & {
+    [I in keyof X]: App<F, X[I]>;
+};
+
+declare const RawStage: unique symbol;
+declare module 'mongodb' {
+    interface Collection<TSchema extends BSON.Document = BSON.Document> {
+        [RawStage]: {
+            (_: 2): TSchema;
+            (_: 1, x: TSchema): TSchema;
+        };
+        s: {
+            db: Db;
+        };
+    }
+    interface Db {
+        s: {
+            client?: MongoClient;
+        };
+        client: MongoClient;
+    }
+    interface Timestamp {
+        toExtendedJSON(): BSON.TimestampExtended;
+    }
+}
+
+interface CommonCollection {
+    readonly s: {
+        readonly db: Db;
+    };
+    collectionName: string;
+    namespace: string;
+    dbName: string;
+    createIndex: Collection['createIndex'];
+}
+interface ReadonlyCollection<out Out> extends CommonCollection {
+    [RawStage](_: 2): Out;
+}
+interface WriteonlyCollection<in R> extends CommonCollection {
+    [RawStage]: {
+        (_: 1, x: R): unknown;
+    };
+}
+interface RWCollection<in R extends O, out Out extends O = R> extends CommonCollection {
+    [RawStage](_: 2): Out;
+    [RawStage](_: 1, x: R): unknown;
+}
+type OPick<V, K extends StrKey<V>, E extends StrKey<V> = never> = O & Pick<V, K | E>;
+type OPickD<V extends Model, K extends StrKey<V>> = OPick<V, K, 'deletedAt' | '_id'>;
+type View<V extends Model, K extends StrKey<V>> = {
+    collection: ReadonlyCollection<V | Del>;
+    projection: ExactKeys<K> | null;
+    match?: Expr<boolean, OPickD<V, K>>;
+    hardMatch?: Query<V>;
+};
+
+declare const val: <T extends rawItem>(val: T) => Expr<T, unknown>;
+declare const current: Expr<Timestamp, unknown>;
+declare const $let: <T, D, C, V extends RORec<string, jsonItem>>(vars: ExprsExact<V, D, C>, inExpr: Expr<T, D, C & V>) => Expr<T, D, C>;
+declare const nil: Expr<null, unknown>;
+declare const $getField: {
+    <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T, D, C>, field: K): Expr<T[K], D, C>;
+    <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T | N, D, C>, field: K): Expr<T[K] | null, D, C>;
+};
+type NoRaw<T> = T extends Arr<infer U> ? NoRaw<U>[] : T extends readonly unknown[] ? {
+    [K in keyof T]: NoRaw<T[K]>;
+} : T extends O ? {
+    [K in StrKey<T>]: NoRaw<T[K]>;
+} : T;
+type RONoRaw<T> = T extends Arr<infer U> ? readonly RONoRaw<U>[] : T extends readonly unknown[] ? {
+    readonly [K in keyof T]: RONoRaw<T[K]>;
+} : T extends O ? {
+    readonly [K in StrKey<T>]: RONoRaw<T[K]>;
+} : T;
+declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: NoRaw<A>) => RONoRaw<T>, ...args: { [X in keyof A]: Expr<A[X], D, C>; }) => Expr<T, D, C>;
+declare const rand: () => string;
+declare const $rand: Expr<string, unknown, unknown>;
+
+declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
+declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => NoRaw<T>, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, A>, accumulate: (a: NoRaw<T>, ...args: NoRaw<A>) => NoRaw<T>, merge: (...args: NoRaw<[T | N, T]>) => NoRaw<T>) => DeltaAccumulator<D, T, Ctx>;
+declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
+declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<V, D, C>) => DeltaAccumulator<D, Rec<string, Rec<"0" | "1", Arr<V>>>, C>;
+declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
+declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec<"1" | "0", Arr<V>>>, D, C>) => Expr<Arr<Rec<"k", string> & Rec<"v", V>>, D, C>;
+
+type MergeInto<T extends O, Out extends O, E = unknown> = {
+    whenNotMatched: 'insert';
+    into: RWCollection<T, Out> & E;
+} | {
+    whenNotMatched: 'discard' | 'fail';
+    into: ReadonlyCollection<Out> & E;
+};
+type MergeArgs<T extends O, Out extends O, Ctx, In extends O> = {
+    on: Field<T, jsonItem> & Field<Out, jsonItem>;
+} & MergeInto<T, Out> & (({
+    stages?: never;
+} & ({
+    whenMatched: 'keepExisting' | 'fail';
+} | {
+    whenMatched: 'replace';
+    into: RWCollection<T, Out>;
+} | {
+    whenMatched: 'merge';
+    into: RWCollection<Replace<Out, T>, Out>;
+})) | {
+    stages: true;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In, {
+        new: T;
+    }>;
+} | {
+    stages: 'ctx';
+    vars: ExprsExact<Ctx, T>;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In, Ctx>;
+});
+declare const $merge_: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>({ into, on, whenNotMatched, ...notMatched }: MergeArgs<T, Out, Ctx, In>) => RawStages<unknown, T, "out", unknown, number>;
+declare const $merge2: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>(args: MergeArgs<T, Out, Ctx, In>) => RawStages<unknown, T, "out", unknown, number>;
+
+type GI$1<GG> = Exclude<GG, keyof TS>;
+type IdAndTsKeys = keyof (TS & ID);
+type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI$1<GG>>;
+type Prepare<Grp, GG extends string> = TS & ID & Rec<GI$1<GG>, Grp>;
+type Par<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
+type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V<VV, GG>;
+type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+type OrReplace<T, V> = T | Replace<T, V>;
+type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, VV, GG>>;
+
+type Denied<GID = never> = keyof (TS & ID) | GID;
+type GI<GG> = Exclude<GG, keyof TS>;
+declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, V, Grp, GG, EE>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
+declare const $groupId: <T extends O, V extends O, EE = {}, Out extends Loose<string, V, "_id"> = Loose<string, V, "_id">>(id: Expr<string, T>, args: DeltaAccumulators<T, O & Omit<V, Denied>>, out: RWCollection<MergedInput<Out, V, string, "_id", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<Delta<T>, "out">;
+declare const $group: <T extends O, Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, "_grp"> = Loose<Grp, V, "_grp">>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<"_grp">>>, out: RWCollection<MergedInput<Out, V, Grp, "_grp", EE> | Strict<Grp, V, "_grp", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | Exclude<keyof V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
+
+type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
+    localField: Field<LQ, S>;
+    foreignField: Field<RQ, S>;
+    from: SnapshotStreamExecutionResult<RQ, RE>;
+    as: AsLiteral<As>;
+};
+declare const $lookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
+declare const $outerLookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE | null>>;
+
+declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
+
+declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;
+
+declare const Updater: unique symbol;
+type Updater<in R, in T, out V, in C = unknown> = {
+    [Type]?(x: typeof Updater, r: R, t: T, c: C): V;
+    readonly raw: <D extends O>(f: Field<D, R | N>) => readonly (readonly [string, rawItem])[];
+};
+interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends HKT<StrKey<V>> {
+    readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
+}
+type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
+declare const set: <V>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit<Old, StrKey<V>> & V>, C>;
+declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
+
+declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V, UpdaterHKT<R, R, V, C>>) => DeltaStages<O, R, Replace<R, V>, C> & LinStages<O, R, Replace<R, V>, C>;
+declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
+
+type s$1 = string;
+declare const $unwindDelta: <K1 extends s$1, T extends doc, K2 extends s$1, U extends doc, N1 extends null = never, N2 extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false, middle?: string, includeNull1?: N1, includeNull2?: N2) => RawStages<Delta<Rec<K1, T | N1>>, Delta<Rec<K1, T | N1> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T | N1> & Rec<K2, U | N2> & ID>>;
+
+type s = string;
+type TOf<TT, K extends string> = doc & Omit<TT, K>;
+declare const $unwind: <TT extends O, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key"> & RORec<"_id", "id">, middle?: string) => DeltaStages<O, TOf<TT, K> & Rec<K, Arr<U>>, TOf<TT, K> & Rec<K, U>>;
+
+type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
+type Allowed$2<K extends string> = Exclude<K, keyof (TS & ID)>;
+type Patch<V, KK extends StrKey<V> = StrKey<V>> = ((OPick<V, Allowed$2<KK>> & ID) | (Rec<Allowed$2<KK>, N> & ID)) & TS;
+type TakeDoc<V, E = ID, KK extends StrKey<V> = StrKey<V>> = OPick<V, Allowed$2<KK>> & E;
+type ND$1 = {
+    readonly deletedAt?: null;
+};
+type SafeE$1<E> = Omit<E, `$${string}` | keyof ID>;
+declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
+declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Rec<"old" | "merged", Out | Replace<Out, P>>, Out | Replace<Out, P>>;
+type MergeCollection<V extends O, Out extends Model> = {
+    coll: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>;
+    whenNotMatched: 'discard';
+} | {
+    coll: RWCollection<Out | Replace<Out, Patch<V>>, Out>;
+    whenNotMatched: 'fail';
+};
+declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends Model, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, id: Expr<string, OutInputE<TakeDoc<V>, E, null>>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
+declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends Model, EEE extends RORec<string, rawItem>>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Source, "out">;
+declare const $simpleMerge: <V extends O>() => <Source extends doc, Out extends Model>(out: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Source, "out">;
+declare const $mergePart: <V extends O>() => <Out extends Model, SourcePart extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Delta<SourcePart>, "out">;
+declare const $merge: <V extends O>() => <Out extends Model, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>) => StreamRunnerParam<Delta<SourcePart>, "out">;
+
+type ND = {
+    readonly deletedAt?: null;
+};
+type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
+type Merge<T extends doc, E> = Omit<SafeE<E>, keyof (ND & TS)> & ((T & ND & TS) | Del);
+declare const $insertX: <T extends doc, D extends O, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, expr: Expr<T, D>, map: (x: Expr<T & ND & TS & Omit<SafeE<EEE>, keyof (ND & TS)>, D>) => Expr<Merge<T, EEE>, D>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, extExpr: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>) => StreamRunnerParam<D, "out">;
+declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
+declare const $insertPart: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Delta<T>, "out">;
+declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
+
+declare const log: (...args: unknown[]) => void;
+
+declare const createIndex: (collection: {
+    readonly createIndex: Collection["createIndex"];
+    collectionName: string;
+}, indexSpec: IndexSpecification, op?: CreateIndexesOptions) => Promise<void>;
+
+declare const noop: () => void;
+declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
+    readonly [_: string]: [K, Im];
+};
+
+declare const $group_: <V extends O>() => <ID, T extends O, C = unknown>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => RawStages<O, T, Rec<"_id", ID> & V, C, 1>;
+
+type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
+    with: <Q2 extends O, V extends Q2>(map: (a: Stream<Q, T, F, G>) => Stream<Q | Q2, V, F, G>) => DeltaPipe<Q | Q2, V, F, G>;
+    then: <Q2 extends O, V extends Q2>(next: App<G, [Q2 | T, T, V]>) => DeltaPipe<Q | Q2, V, F, G>;
+    get: () => App<F, [Q, T]>;
+};
+
+type AllowedPick$1<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed$1<K>>;
+type Allowed$1<K> = Exclude<K, 'deletedAt' | '_id'>;
+
+interface SnapshotStreamHKT extends HKT<O2> {
+    readonly out: SnapshotStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
+}
+interface DeltaHKT extends HKT<O3> {
+    readonly out: DeltaStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2]>;
+}
+declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>> & {
+    needs?: Partial<Record<KK, 0 | 1>>;
+}, streamName: string, skip?: boolean, after?: () => Promise<void>) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT, DeltaHKT>;
+
+type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
+type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
+interface StreamRunnerHKT extends HKT<O2> {
+    readonly out: SimpleStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
+}
+interface StagesHKT extends HKT<O3> {
+    readonly out: RORec<'lin', RawStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2], unknown, 1>>;
+}
+declare const from: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string, needs?: Partial<Record<KK, 0 | 1>>) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
+
+type SingleResult<out Result> = <Result2>(finalInput: RawStages<unknown, Result, Result2>) => Stages<unknown, Result2, unknown>;
+interface SnapshotStreamHKT2 extends HKT<O2> {
+    readonly out: SingleResult<I<O2, this>[1]>;
+}
+declare const single: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>>, needs?: Partial<Record<KK, 0 | 1>>) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT2, DeltaHKT>;
+
+declare const max: <D, C>(...expr: Expr<number, D, C>[]) => Expr<number, D, C>;
+declare const lt: {
+    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
+};
+declare const gt: {
+    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
+};
+declare const lte: {
+    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
+};
+declare const gte: {
+    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
+};
+type Num = number | null | undefined;
+declare function subtract<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function subtract<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function add<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function add<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function divide<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function divide<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function multiply<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function multiply<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function floor<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
+declare function floor<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
+declare function ceil<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
+declare function ceil<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
+
+declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
+declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
+declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
+    expr: Expr<Arr<T>, D, C>;
+    as: K;
+    cond: Expr<unknown, D, C & RORec<K, T>>;
+    limit?: Expr<number, D, C>;
+}) => Expr<Arr<T>, D, C>;
+declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
+    expr: Expr<Arr<T>, D, C>;
+    sortBy: K;
+    order?: 1 | -1;
+}) => Expr<Arr<T>, D, C>;
+declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
+declare const inArray: <T, D, C>(item: Expr<T, D, C>, expr: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
+declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
+declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+type NullToOBJ<N extends null> = N extends null ? O : N;
+declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(...exprs: readonly [Expr<T1 | N, D, C>, ...[...Expr<T1 | T2 | N, D, C>[], Expr<T2, D, C>]]) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
+declare const anyElementTrue: <D, C = unknown>(expr: Expr<Arr<boolean>, D, C>) => Expr<boolean, D, C>;
+type Reduce<T, V> = RORec<'value', V> & RORec<'this', T>;
+declare const $reduce: <T, V, D, C>(input: Expr<Arr<T>, D, C>, initialValue: Expr<V, D, C>, inExpr: Expr<V, D, C & Reduce<T, V>>) => Expr<V, D, C>;
+declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
+declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
+
+declare const dayAndMonthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const now: <D, C>() => Expr<Date, D, C>;
+declare const monthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const weekPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const year: <D, C>(date: Expr<Date, D, C>) => Expr<number, D, C>;
+declare const dateAdd: <D, C>(date: Expr<Date, D, C>, amount: Expr<number, D, C>, unit: Expr<"year" | "week" | "month" | "day" | "hour" | "minute" | "second", D, C>) => Expr<Date, D, C>;
+declare const maxDate: <D, C>(expr: Expr<Arr<Date>, D, C>) => Expr<Date, D, C>;
+declare const minDate: <D, C>(expr: Expr<Arr<Date>, D, C>) => Expr<Date, D, C>;
+declare const datePart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const startOf: <D, C>(startDate: Expr<Date, D, C>, freq: Expr<"week" | "day" | "month" | "year", D, C>, offset: Expr<number, D, C>) => Expr<Date, D, C>;
+declare const dateDiff: <D, C>({ end, unit, start, }: {
+    start: Expr<Date, D, C>;
+    end: Expr<Date, D, C>;
+    unit: Expr<"week" | "day" | "month" | "year", D, C>;
+}) => Expr<number, D, C>;
+
+declare const ite: {
+    <T, D, C = unknown>(cond: Expr<unknown, D, C>, then: Expr<T, D, C>, orelse: Expr<T, D, C>): Expr<T, D, C>;
+    <T, R1, R2, F extends HKT<R1 | R2>, C = unknown>(cond: BoolExpr<App<F, R1>, App<F, R2>, C>, then: Expr<T, App<F, R1>, C>, orelse: Expr<T, App<F, R2>, C>): Expr<T, App<F, R1 | R2>, C>;
+};
+declare const and: <D, C = unknown>(...expr: Expr<boolean, D, C>[]) => Expr<boolean, D, C>;
+declare const or: <D, C = unknown>(...expr: Expr<boolean, D, C>[]) => Expr<boolean, D, C>;
+declare const not: <D, C = unknown>(expr: Expr<boolean, D, C>) => Expr<boolean, D, C>;
+declare const eq: <T, D, C = unknown>(a: Expr<T, D, C>) => (b: Expr<T, D, C>) => Expr<boolean, D, C>;
+declare const sub: <T, D, Ctx, P extends O>(a: Expr<T, D, Ctx>, f: Field<P, D, Ctx>) => Expr<T, P, Ctx>;
+declare const eqTyped: <T1 extends Dom, T2 extends Dom, F extends HKT<Dom>, C = unknown, Dom = unknown>(a: Expr<T1 | T2, App<F, T1 | T2>, C>, b: Expr<T1, App<F, T1 | T2>, C>) => BoolExpr<App<F, T1>, App<F, T2>, C>;
+declare const ne: <T, D, C>(a: Expr<T, D, C>) => <K>(b: Expr<K, D, C>) => Expr<boolean, D, C>;
+declare const notNull: <T, D, C>(a: Expr<T, D, C>) => Expr<boolean, D, C>;
+declare const $ifNull: <R, D, C>(...expr: [...Expr<R | null | undefined, D, C>[], Expr<R, D, C>]) => Expr<R, D, C>;
+declare const exprMapVal: <K extends string, T extends Partial<Record<K, rawItem>>, D, C>(expr: Expr<K, D, C>, map: { readonly [P in K]: Expr<T[P], D, C>; }, or?: Expr<T[K], D, C>) => Expr<T[K & keyof T], D, C>;
+declare const mapVal: <K extends string, T extends Partial<Record<K, rawItem>>, D, C>(expr: Expr<K, D, C>, map: T, or: T[K & keyof T]) => Expr<T[K & keyof T], D, C>;
+declare const setField: <K extends string, T, V, D, C>({ field, input, value, }: {
+    field: Expr<K, D, C>;
+    input: Expr<T, D, C>;
+    value: Expr<V, D, C>;
+}) => Expr<T & Record<K, V>, D, C>;
+
+declare const range: <D, C>(start: Expr<number, D, C>, end: Expr<number, D, C>, step?: Expr<number, D, C>) => Expr<Arr<number>, D, C>;
+declare const $map0: <K extends string, T, R, D, C>({ as, expr, input, }: {
+    input: Expr<Arr<T>, D, C>;
+    as: K;
+    expr: Expr<R, D, RORec<K, T> & C>;
+}) => Expr<Arr<R>, D, C>;
+declare const $map1: <T, R, D, C>(ex: Expr<Arr<T>, D, C>, map: (i: Field<unknown, T, RORec<"item", T>>) => Expr<R, D, RORec<"item", T> & C>) => Expr<Arr<R>, D, C>;
+declare const $map: <T, R, D, C = unknown>(ex: Expr<Arr<T>, D, C>, map: (i: Expr<T, D, RORec<"item", T>>) => Expr<R, D, RORec<"item", T> & C>) => Expr<Arr<R>, D, C>;
+
+declare class Machine<Result = unknown> {
+    private sources;
+    constructor(root?: Iterator<Result, HasJob>);
+    add(x: Iterator<Result, HasJob>): void;
+    runner(): Iterator<Result, HasJob>;
+    start(cb?: (info: HasJob) => void | boolean): Promise<never>;
+}
+declare const wrap: <Result>(root: Machine<Result>) => Machine<Result>;
+
+declare const $eq: <T extends unknown>(operand: rawItem & T) => Predicate<T>;
+declare const $ne: <T extends unknown>(operand: rawItem & T) => Predicate<T>;
+type Numeric = number | Timestamp | Date;
+declare const comp: <D2 extends Numeric = Numeric>(op: "$gt" | "$gte" | "$lt" | "$lte") => <T extends Numeric>(operand: rawItem & D2) => Predicate<D2>;
+declare const $gt: <T extends Numeric>(operand: rawItem & Numeric) => Predicate<Numeric>;
+declare const $gtTs: <T extends Numeric>(operand: rawItem & Timestamp) => Predicate<Timestamp>;
+declare const $gteTs: <T extends Numeric>(operand: rawItem & Timestamp) => Predicate<Timestamp>;
+declare const $lt: <T extends Numeric>(operand: rawItem & number) => Predicate<number>;
+declare const dateLt: <T extends Numeric>(operand: rawItem & Date) => Predicate<Date>;
+declare const $gte: <T extends Numeric>(operand: rawItem & number) => Predicate<number>;
+declare const $lte: <T extends Numeric>(operand: rawItem & number) => Predicate<number>;
+type MongoTypes = {
+    number: number;
+    array: readonly rawItem[];
+    string: string;
+    object: RawObj;
+    [i: number]: unknown;
+};
+type MongoTypeNames = keyof MongoTypes;
+declare const $type: <T extends keyof MongoTypes>(operand: rawItem & readonly T[]) => Predicate<N | MongoTypes[T]>;
+declare const $exists: <T extends keyof MongoTypes>(operand: rawItem & boolean) => Predicate<unknown>;
+
+declare const $expr: <D extends O, C>(expr: Expr<boolean, D, C>) => Query<D, C>;
+
+declare const $in: <T extends unknown>(operand: rawItem & readonly T[]) => Predicate<T>;
+declare const $nin: <T extends unknown>(operand: rawItem & readonly T[]) => Predicate<T>;
+
+type Many<T> = readonly (T | N)[];
+type Combiner = {
+    <T extends O, C = unknown>(first: Query<T, C>, ...args: Many<Query<T, C>>): Query<T, C>;
+    <T extends O, C = unknown>(...args: Many<Query<T, C>>): Query<T, C> | undefined;
+};
+declare const $and: Combiner;
+declare const $nor: Combiner;
+declare const $or: Combiner;
+
+declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<Document>;
+declare const prepare: (testName?: string) => Promise<MongoClient$1>;
+declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
+
+export { $accumulator, $and, $countDict, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $sum, $type, $unwind, $unwindDelta, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export type { Accumulators, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, ExactKeys, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, Loose, Merge, MergeArgs, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NoRaw, NullToOBJ, O, OPick, OPickD, Patch, RONoRaw, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WriteonlyCollection, doc, jsonPrim, notArr };

package/index.esm.js

@@ -1272,7 +1272,7 @@ const createIndex = async (collection, indexSpec, op) => {
 };
 const createIndexWithRetry = async (collection, indexSpec, options) => {
     const log = () => { };
-    log('Creating index', { collection: collection.collectionName, indexSpec, options });
+    log('Creating index', { collection: collection.collectionName});
     while (true) {
         try {
             await collection.createIndex(indexSpec, options);
@@ -1280,7 +1280,7 @@ const createIndexWithRetry = async (collection, indexSpec, options) => {
         }
         catch (e) {
             if ([85, 276].includes(e.code)) {
-                log('Index created with different name', e.code, { collection: collection.collectionName, indexSpec, options });
+                log('Index created with different name', e.code, { collection: collection.collectionName});
                 break;
             }
             if (e.code == 12587) {
@@ -1288,11 +1288,7 @@ const createIndexWithRetry = async (collection, indexSpec, options) => {
                 continue;
             }
             log('Error creating index', {
-                collection: collection.collectionName,
-                indexSpec,
-                options,
-                error: e,
-            });
+                collection: collection.collectionName});
             console.error('Error creating index', e);
             throw e;
         }
@@ -1370,7 +1366,7 @@ const firstWorksMerge = (iters) => {
         const sources = { ...results };
         return mergeIterators({
             sources,
-            interrupt: key => state.steady,
+            interrupt: key => false,
             hooks: {
                 start: (frame, result) => {
                     if (!frame.info.job)
@@ -1569,14 +1565,18 @@ const aggregate = (db, streamName, input, snapshot = true, start = Date.now()) =
     };
     log('exec', streamName, req);
     const start2 = Date.now();
-    return db.then(d => d.command(req)).then(result => {
+    return db
+        .then(d => d.command(req))
+        .then(result => {
         log('prepare', streamName, Date.now() - start);
         log('prepare2', streamName, start2 - start);
         const r = result;
         log('execed', streamName, (replace) => replace(JSON.stringify(req).replaceAll('"$$CLUSTER_TIME"', JSON.stringify(r.cursor.atClusterTime))), result, 'took', Date.now() - start);
         return r;
-    }, err => {
+    }, async (err) => {
         log('err', req, err);
+        console.error(err);
+        await new Promise(() => { });
         throw new Error(err);
     });
 });
@@ -1718,16 +1718,7 @@ const loop = async (db) => {
             }
             continue;
         }
-        const groupBy = (arr, fn) => {
-            return arr.reduce((acc, x) => {
-                const k = fn(x);
-                if (!acc[k])
-                    acc[k] = [];
-                acc[k].push(x);
-                return acc;
-            }, {});
-        };
-        const groups = groupBy(events.filter(e => e.changeTouched), ev => ev.doc.ns);
+        const groups = Object.groupBy(events.filter(e => e.changeTouched), ev => ev.doc.ns);
         for (const [ns, evs] of Object.entries(groups)) {
             if (!evs)
                 continue;

package/index.js

@@ -1274,7 +1274,7 @@ const createIndex = async (collection, indexSpec, op) => {
 };
 const createIndexWithRetry = async (collection, indexSpec, options) => {
     const log = () => { };
-    log('Creating index', { collection: collection.collectionName, indexSpec, options });
+    log('Creating index', { collection: collection.collectionName});
     while (true) {
         try {
             await collection.createIndex(indexSpec, options);
@@ -1282,7 +1282,7 @@ const createIndexWithRetry = async (collection, indexSpec, options) => {
         }
         catch (e) {
             if ([85, 276].includes(e.code)) {
-                log('Index created with different name', e.code, { collection: collection.collectionName, indexSpec, options });
+                log('Index created with different name', e.code, { collection: collection.collectionName});
                 break;
             }
             if (e.code == 12587) {
@@ -1290,11 +1290,7 @@ const createIndexWithRetry = async (collection, indexSpec, options) => {
                 continue;
             }
             log('Error creating index', {
-                collection: collection.collectionName,
-                indexSpec,
-                options,
-                error: e,
-            });
+                collection: collection.collectionName});
             console.error('Error creating index', e);
             throw e;
         }
@@ -1372,7 +1368,7 @@ const firstWorksMerge = (iters) => {
         const sources = { ...results };
         return mergeIterators({
             sources,
-            interrupt: key => state.steady,
+            interrupt: key => false,
             hooks: {
                 start: (frame, result) => {
                     if (!frame.info.job)
@@ -1571,14 +1567,18 @@ const aggregate = (db, streamName, input, snapshot = true, start = Date.now()) =
     };
     log('exec', streamName, req);
     const start2 = Date.now();
-    return db.then(d => d.command(req)).then(result => {
+    return db
+        .then(d => d.command(req))
+        .then(result => {
         log('prepare', streamName, Date.now() - start);
         log('prepare2', streamName, start2 - start);
         const r = result;
         log('execed', streamName, (replace) => replace(JSON.stringify(req).replaceAll('"$$CLUSTER_TIME"', JSON.stringify(r.cursor.atClusterTime))), result, 'took', Date.now() - start);
         return r;
-    }, err => {
+    }, async (err) => {
         log('err', req, err);
+        console.error(err);
+        await new Promise(() => { });
         throw new Error(err);
     });
 });
@@ -1720,16 +1720,7 @@ const loop = async (db) => {
             }
             continue;
         }
-        const groupBy = (arr, fn) => {
-            return arr.reduce((acc, x) => {
-                const k = fn(x);
-                if (!acc[k])
-                    acc[k] = [];
-                acc[k].push(x);
-                return acc;
-            }, {});
-        };
-        const groups = groupBy(events.filter(e => e.changeTouched), ev => ev.doc.ns);
+        const groups = Object.groupBy(events.filter(e => e.changeTouched), ev => ev.doc.ns);
         for (const [ns, evs] of Object.entries(groups)) {
             if (!evs)
                 continue;

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.1.27",
+    "version": "0.1.28",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",