@omegup/msync 0.1.53 → 0.1.55

package/index.js

@@ -402,8 +402,6 @@ const fieldM = (expr, m) => asExpr({
 const mergeExact = (...[exprsExact1, exprsExact2]) => spread(exprsExact1, exprsExact2);
 const mergeExact0 = (...[exprsExact1, exprsExact2]) => spread0(exprsExact1, exprsExact2);
 const mergeExpr = (...exprs) => mergeExact(...exprs);
-const asIntersect = (x) => x;
-const pair = (k, v) => asIntersect([k, v]);
 const fieldF = () => (exprs) => Object.keys(exprs).length
     ? asExpr({
         raw: f => asExprRaw(mapExactToObject(exprs, e => e.raw(f).get())),
@@ -439,7 +437,6 @@ const renamedFields = () => assertEqual();
 const translateOmit = () => assertEqual();
 const excludeIdem = () => assertEqual();
 const eqPar = () => assertEqual();
-const notExtendExcluded = () => assertEqual();
 
 const size = (expr) => asExpr({
     raw: f => asExprRaw({ $size: expr.raw(f).get() }),
@@ -947,7 +944,9 @@ const getWhenMatched = (whenNotMatched) => {
     return link().with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
 };
 const $mergeX = (out, keys, f, map, ext, update) => {
-    const patch = mapExact(keys, v => sub(v, f));
+    const patch = mapExact(keys, (v) => {
+        return $ifNull(sub(v, f), nil);
+    });
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     const setDeleted = out.whenNotMatched === 'discard';
     const replacer = map(field(omitPick().backward(spread(patch, {
@@ -1164,48 +1163,12 @@ const joinIdOf = (k, k1, k1Id, k2Id) => {
     return concat(idOf(k[0]), val(k[1]), idOf(k[2]));
 };
 const andAlso = (probe, keep) => ite(eqTyped(probe, nil), nil, keep);
-const notObjAndAlso = (probe, keep) => ite(eqTyped(probe, field({})), nil, keep);
-const $unwindDelta = (k1, k2, k, includeNull1, includeNull2) => {
+const slotsMany = (k1, k2, k, emptyOf) => {
     const emptyArr = array();
     const src = root();
     const k2Arr = (side) => src.of(side).of(k2).expr();
     const k2OrEmpty = (side) => $ifNull(k2Arr(side), emptyArr);
-    const k2Empty = (side) => eq(k2Arr(side))(emptyArr);
-    const beforeItems = k2OrEmpty('before');
-    const afterItems = k2OrEmpty('after');
-    const beforeIds = $map1(beforeItems, (item) => item.of('_id').expr());
-    const newByK2Id = filter({
-        expr: afterItems,
-        as: 'a',
-        cond: not(inArray(ctx()('a').of('_id').expr(), beforeIds)),
-    });
-    const oldByK2Id = $map0({
-        input: beforeItems,
-        as: 'b',
-        expr: field({
-            before: ['before', ctx()('b').expr()],
-            after: [
-                'after',
-                first$1(filter({
-                    expr: afterItems,
-                    as: 'a',
-                    cond: eq(ctx()('a').of('_id').expr())(ctx()('b').of('_id').expr()),
-                })),
-            ],
-        }),
-    });
-    const k1Slot = (fill) => array(field({
-        before: [
-            'before',
-            $ifNull(first$1(beforeItems), fill),
-        ],
-        after: [
-            'after',
-            $ifNull(first$1(afterItems), fill),
-        ],
-    }));
-    const kept = k === k1 ? k1Slot(nil) : oldByK2Id;
-    const added = k === k1 ? emptyArr : newByK2Id;
+    const k1Id = root().of('_id').expr();
     const k1Delta = field({
         before: [
             'before',
@@ -1215,154 +1178,132 @@ const $unwindDelta = (k1, k2, k, includeNull1, includeNull2) => {
             'after',
             $ifNull(src.of('after').of(k1).expr(), nil),
         ],
+        deleted: ['deleted', src.of('deleted').expr()],
     });
-    const unwindJoin = ({ kept, added, padToNull, isPad, join, }) => {
-        const newDeltas = $map0({
-            input: added,
-            as: 'a',
+    const itemId = (k2Id) => {
+        const at = (key) => (key === k1 ? k1Id : k2Id);
+        if (typeof k === 'string')
+            return at(k);
+        return concat(at(k[0]), val(k[1]), at(k[2]));
+    };
+    const keyed = (side) => {
+        const items = ctx()('items').expr();
+        return $let({ items: ['items', k2OrEmpty(side)] }, ite(eq(items)(emptyArr), emptyOf(k1Id), $map0({
+            input: items,
+            as: 'b',
             expr: field({
-                before: ['before', nil],
-                after: ['after', ctx()('a').expr()],
+                _id: ['_id', itemId(ctx()('b').of('_id').expr())],
+                value: ['value', ctx()('b').expr()],
             }),
-        });
-        const deltas = mergeObjects(field(map1(k1, k1Delta)), field(map1(k2, concatArray(kept, newDeltas))));
-        const doc = root();
-        const parentId = doc.of('_id').expr();
-        const k1At = (side) => doc.of(k1).of(side).expr();
-        const k2Raw = (side) => doc.of(k2).of(side).expr();
-        const docK2Null = root();
-        const k2Keep = (side) => docK2Null.of(k2).of(side).expr();
-        const k2At = (side) => padToNull(k2Raw(side), k2Keep(side));
-        const rowOf = (id, a, b) => mergeObjects(mergeObjects(field({ _id: ['_id', id] }), field(map1(k1, a))), field(map1(k2, b)));
-        const docK1 = root();
-        const k2RawK1 = (side) => docK1.of(k2).of(side).expr();
-        const k2KeepK1K2 = (side) => root().of(k2).of(side).expr();
-        const rowOnK1 = (side) => {
-            const t = docK1.of(k1).of(side);
-            return rowOf(t.of('_id').expr(), t.expr(), padToNull(k2RawK1(side), k2KeepK1K2(side)));
-        };
-        const docK2 = root();
-        const k1AtK2 = (side) => docK2.of(k1).of(side).expr();
-        const rowOnK2 = (side) => {
-            const u = docK2.of(k2).of(side);
-            return rowOf(u.of('_id').expr(), k1AtK2(side), u.expr());
-        };
-        const docK1K2 = root();
-        const k1AtK1K2 = (side) => docK1K2.of(k1).of(side).expr();
-        const k2AtK1K2 = (side) => docK1K2.of(k2).of(side).expr();
-        const k1IdK1K2 = (side) => docK1K2.of(k1).of(side).of('_id').expr();
-        const k2IdK1K2 = (side) => docK1K2.of(k2).of(side).of('_id').expr();
-        const completeId = (side) => joinIdOf(k, k1, k1IdK1K2(side), k2IdK1K2(side));
-        const rowK1K2 = (side) => rowOf(completeId(side), k1AtK1K2(side), k2AtK1K2(side));
-        const liftRowId = $replaceWith_(mergeObjects(root().expr(), field({
-            _id: [
-                '_id',
-                $ifNull(root()
-                    .of('before')
-                    .of('_id')
-                    .expr(), root()
-                    .of('after')
-                    .of('_id')
-                    .expr(), root().of('_id').expr()),
-            ],
         })));
-        const padded = (side) => isPad(k2Raw(side));
-        const emptyObj = field({});
-        const deletedFlags = mergeObjects(ite(padded('before'), field({ before: ['before', val(true)] }), emptyObj), ite(padded('after'), field({ after: ['after', val(true)] }), emptyObj));
-        const joinAt = (side) => join({
-            k1: k1At(side),
-            k2: k2At(side),
-            rowK1K2: rowK1K2(side),
-            rowOnK1: rowOnK1(side),
-            rowOnK2: rowOnK2(side),
-            k2Keep: k2Keep(side),
-            k2Raw: k2Raw(side),
-            k2RawK1: k2RawK1(side),
-            k2KeepK1K2: k2KeepK1K2(side),
-        });
-        const joinDelta = mergeObjects(field({
-            _id: ['_id', parentId],
-            before: ['before', joinAt('before')],
-            after: ['after', joinAt('after')],
-        }), ite(or(padded('before'), padded('after')), field({ deleted: ['deleted', deletedFlags] }), emptyObj));
-        return link()
-            .with($replaceWith_(mergeObjects(src.expr(), deltas)))
-            .with($unwind_(k2))
-            .with($replaceWith_(joinDelta))
-            .with(matchDelta())
-            .with(liftRowId).stages;
     };
-    const noPadToNull = (k2) => k2;
-    const neverPad = (_k2) => val(false);
-    if (includeNull2 === null) {
-        const padObj = field({});
-        const padDelta = (after) => field({
-            before: ['before', padObj],
-            after: ['after', after],
-        });
-        const addedPadded = k === k1
-            ? array()
-            : ite(and(not(k2Empty('before')), k2Empty('after')), array(padObj), added);
-        const padToNull = (k2, keep) => ite(eqTyped(k2, field({})), nil, keep);
-        const isPad = (k2) => ite(eqTyped(k2, field({})), val(true), val(false));
-        const keptMatched = ite(k2Empty('before'), ite(k2Empty('after'), array(padDelta(padObj)), array(padDelta(nil))), kept);
-        const padded = { added: addedPadded, padToNull, isPad };
-        if (includeNull1 === null) {
-            if (k === k1) {
-                return unwindJoin({
-                    ...padded,
-                    kept: k1Slot(padObj),
-                    join: ({ k1: k1Val, rowOnK1 }) => andAlso(k1Val, rowOnK1),
-                });
-            }
-            if (k === k2) {
-                return unwindJoin({
-                    ...padded,
-                    kept: keptMatched,
-                    join: ({ k2Raw, k2Keep, rowOnK2 }) => notObjAndAlso(k2Raw, andAlso(k2Keep, rowOnK2)),
-                });
-            }
-            return unwindJoin({
-                ...padded,
-                kept: keptMatched,
-                join: ({ k1: k1Val, k2RawK1, k2KeepK1K2, rowK1K2 }) => andAlso(k1Val, notObjAndAlso(k2RawK1, andAlso(k2KeepK1K2, rowK1K2))),
-            });
-        }
-        const eq2 = literalsEqaul();
-        if (k === k1) {
-            return unwindJoin({
-                ...padded,
-                kept: k1Slot(padObj),
-                join: ({ k1: k1Val, rowOnK1 }) => andAlso(k1Val, rowOnK1),
-            });
+    const beforeKeyed = keyed('before');
+    const afterKeyed = keyed('after');
+    const bound = (name) => ctx()(name).expr();
+    const idOf = (name) => ctx()(name).of('_id').expr();
+    const valueOf = (name) => ctx()(name).of('value').expr();
+    const kept = $map0({
+        input: bound('beforeK'),
+        as: 'b',
+        expr: field({
+            _id: ['_id', idOf('b')],
+            before: ['before', valueOf('b')],
+            after: [
+                'after',
+                first$1($map0({
+                    input: filter({
+                        expr: bound('afterK'),
+                        as: 'a',
+                        limit: val(1),
+                        cond: eq(idOf('a'))(idOf('b')),
+                    }),
+                    as: 'a',
+                    expr: valueOf('a'),
+                })),
+            ],
+        }),
+    });
+    const beforeIds = $map0({
+        input: bound('beforeK'),
+        as: 'id',
+        expr: ctx()('id').of('_id').expr(),
+    });
+    const added = $map0({
+        input: filter({
+            expr: bound('afterK'),
+            as: 'a',
+            cond: not(inArray(idOf('a'), beforeIds)),
+        }),
+        as: 'a',
+        expr: field({
+            _id: ['_id', idOf('a')],
+            before: ['before', nil],
+            after: ['after', valueOf('a')],
+        }),
+    });
+    const slots = $let({
+        beforeK: ['beforeK', beforeKeyed],
+        afterK: ['afterK', afterKeyed],
+    }, concatArray(kept, added));
+    const exclude = excludeIdem();
+    return $replaceWith_(field(exclude.backward(mergeExpr(exclude.forward(map1(k2, slots)), map1(k1, k1Delta)))));
+};
+const noEmpty = (_id) => array();
+const padEmpty = (id) => array(field({
+    _id: ['_id', id],
+    value: ['value', field({})],
+}));
+const joinMany = (k1, k2, eq1, eq2) => {
+    const doc = root();
+    const id = () => root().of(k2).of('_id').expr();
+    const k1At = (side) => doc.of(k1).of(side).expr();
+    const rowOf = (a, b) => mergeObjects(mergeObjects(field({ _id: ['_id', id()] }), field(map1(k1, a))), field(map1(k2, b)));
+    const rowPad = (k1v, n2) => {
+        return rowOf(k1v, n2.forward(nil));
+    };
+    const rowReal = (k1v, k2v) => rowOf(k1v, k2v);
+    const k2join = (raw, orNull, pad, real) => ite(eqTyped(raw, field({})), pad, andAlso(orNull, real));
+    const joinAt = (side) => {
+        const k2t = () => root().of(k2).of(side).expr();
+        const k2w = () => root().of(k2).of(side).expr();
+        if (!eq1) {
+            const k1t = () => root().of(k1).of(side).expr();
+            return andAlso(k1At(side), k2join(k2t(), k2t(), eq2 ? rowPad(k1t(), eq2) : nil, rowReal(k1t(), k2t())));
         }
-        return unwindJoin({
-            ...padded,
-            kept: keptMatched,
-            join: ({ k1: k1Val, k2RawK1, k2KeepK1K2, rowK1K2 }) => andAlso(k1Val, notObjAndAlso(k2RawK1, andAlso(k2KeepK1K2, eq2.forward(rowK1K2)))),
-        });
-    }
-    if (includeNull1 === null) {
-        const eq1 = literalsEqaul();
-        return unwindJoin({
-            kept,
-            added,
-            padToNull: noPadToNull,
-            isPad: neverPad,
-            join: ({ k1, k2: k2Val, k2KeepK1K2, rowK1K2, rowOnK2 }) => {
-                return k === k2
-                    ? andAlso(k2Val, rowOnK2)
-                    : andAlso(k1, andAlso(k2KeepK1K2, eq1.forward(rowK1K2)));
-            },
-        });
-    }
-    return unwindJoin({
-        kept,
-        added,
-        padToNull: noPadToNull,
-        isPad: neverPad,
-        join: ({ k1, k2KeepK1K2, rowK1K2 }) => andAlso(k1, andAlso(k2KeepK1K2, rowK1K2)),
+        const k1v = () => {
+            return $ifNull(root().of(k1).of(side).expr(), eq1.forward(nil));
+        };
+        return k2join(k2w(), k2w(), eq2 ? rowPad(k1v(), eq2) : nil, rowReal(k1v(), k2w()));
+    };
+    const isPad = (side) => ite(eq(doc.of(k2).of(side).expr())(field({})), val(true), doc.of(k1).of('deleted').of(side).expr());
+    const joinDelta = field({
+        _id: ['_id', id()],
+        before: ['before', joinAt('before')],
+        after: ['after', joinAt('after')],
+        deleted: [
+            'deleted',
+            field({
+                before: ['before', isPad('before')],
+                after: ['after', isPad('after')],
+            }),
+        ],
     });
+    return $replaceWith_(joinDelta);
+};
+const $unwindDelta = (k1, k2, k, includeNull1, includeNull2) => {
+    const stages = (emptyOf, eq1, eq2) => {
+        return link()
+            .with(slotsMany(k1, k2, k, emptyOf))
+            .with($unwind_(k2))
+            .with(joinMany(k1, k2, eq1, eq2))
+            .with(matchDelta()).stages;
+    };
+    const run = (emptyOf) => stages(emptyOf, includeNull1 === null && literalsEqaul(), includeNull2 === null && literalsEqaul());
+    if (k === k2)
+        return run(noEmpty);
+    if (includeNull2 === null)
+        return run(padEmpty);
+    return run(noEmpty);
 };
 
 const $unwind = (k, dict, middle = '.') => {
@@ -1399,7 +1340,10 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
     const normForeignKey = (f) => to($ifNull(root().of(f).of(k1).with(field1).expr(), val(hash)));
     return link()
         .with($replaceWithDelta(field(map1(k1, root().expr()))))
-        .with($set_(set()({ bId: ['bId', normForeignKey('before')], aId: ['aId', normForeignKey('after')] })))
+        .with($set_(set()({
+        bId: ['bId', normForeignKey('before')],
+        aId: ['aId', normForeignKey('after')],
+    })))
         .with($simpleLookup_({
         coll,
         k: 'a',
@@ -1421,15 +1365,21 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
         pipeline: link().with(input).with(exec).stages,
     }))
         .with($replaceWithEach((f) => {
-        const f1 = f === 'after' ? 'a' : 'b';
-        const a = root().of(f1).of('before').expr();
-        const part = root().of(f);
-        return ite(eq(root().of(f).expr())(nil), nil, field(omit.backward(mergeExpr(omit.forward(map1(k2, a)), map1(k1, part.of(k1).expr())))));
+        const joined = (side, arr) => {
+            const here = root();
+            return ite(eqTyped(root().of(side).expr(), nil), nil, field(omit.backward(mergeExpr(omit.forward(map1(k2, here.of(arr).of('before').expr())), map1(k1, here
+                .of(side)
+                .of(k1)
+                .expr())))));
+        };
+        return f === 'after' ? joined('after', 'a') : joined('before', 'b');
     }))
         .with(includeNull1 === null
-        ? $replaceWithEach1((f) => {
-            const otherField = root().of(f === 'after' ? 'before' : 'after');
-            return $ifNull(root().of(f).expr(), field(omit.backward(mergeExpr(omit.forward(map1(k2, otherField.of(k2).expr())), map1(k1, nil)))));
+        ? $replaceWithEach1((part) => {
+            const otherPart = root().of(part === 'after' ? 'before' : 'after');
+            const n1 = literalsEqaul().forward(nil);
+            const expr = $ifNull(root().of(part).expr(), field(omit.backward(mergeExpr(omit.forward(map1(k2, otherPart.of(k2).expr())), map1(k1, n1)))));
+            return expr;
         })
         : link().stages)
         .with($unwindDelta(k1, k2, k, includeNull1, includeNull2)).stages;
@@ -2609,7 +2559,6 @@ exports.ne = ne;
 exports.nil = nil;
 exports.noop = noop;
 exports.not = not;
-exports.notExtendExcluded = notExtendExcluded;
 exports.notNull = notNull;
 exports.now = now;
 exports.omitExclude = omitExclude;
@@ -2617,7 +2566,6 @@ exports.omitPick = omitPick;
 exports.omitRORec = omitRORec;
 exports.or = or;
 exports.padLeft = padLeft;
-exports.pair = pair;
 exports.prepare = prepare;
 exports.rand = rand;
 exports.range = range;

package/lib/accumulators/index.d.ts

@@ -0,0 +1,28 @@
+import type { AppMap, N, O, PRRec } from '../../types';
+import type { ExprHKT } from '../expression/concat';
+import { type AddO } from '../expression/val';
+import type { DeltaAccumulator, Expr, Part } from '../types';
+type AddOs<A extends readonly unknown[]> = {
+    [K in keyof A]: AddO<A[K]>;
+};
+type PushSides<V> = {
+    0: V[];
+    1: V[];
+};
+type PushDict<V> = PRRec<string, PushSides<V>>;
+export declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
+export declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => T, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, AddOs<A>>, accumulate: (a: T, ...args: A) => T, merge: (...args: [T | N, T]) => T) => DeltaAccumulator<D, AddO<T>, Ctx>;
+export declare const $countDict: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
+export declare const $countDictArray: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K[]>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
+export declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<AddO<V>, D, C>) => DeltaAccumulator<D, O<{
+    [x: string]: O<{
+        0: import("../..").Arr<AddO<V>>;
+        1: import("../..").Arr<AddO<V>>;
+    }> | undefined;
+}>, C>;
+export declare const $keys: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<PRRec<K, number>>, D, C>) => Expr<AddO<K[]>, D, C>;
+export declare const $entries: <D extends O, V, C = unknown>(expr: Expr<AddO<PushDict<V>>, D, C>) => Expr<AddO<{
+    k: string;
+    v: V;
+}[]>, D, C>;
+export {};

package/lib/aggregate/$merge.d.ts

@@ -0,0 +1,37 @@
+import type { IdHKT, OPick, RWCollection, Timestamp } from '../../types';
+import type { doc, ID, N, O, rawItem, Rec, Replace, RORec, StrKey } from '../../types/json';
+import { type ExprsExact } from '../expression/concat';
+import type { Delta, Expr, IsDeleted, Model, RawStages, StreamRunnerParam, TS } from '../types';
+import { type Exact } from '../utils/map-object';
+type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
+type Allowed<K extends string> = Exclude<K, keyof (TS & ID)>;
+export type Patch<V, KK extends StrKey<V> = StrKey<V>> = ((OPick<V, Allowed<KK>> & ID) | (Rec<Allowed<KK>, N> & ID)) & TS;
+type TakeDoc<V, E = ID, KK extends StrKey<V> = StrKey<V>> = OPick<V, Allowed<KK>> & E;
+type ND = {
+    readonly deletedAt?: null;
+};
+type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
+type Args<P, Out> = [added: Expr<P, unknown, {
+    new: P;
+}>, old: Expr<Out, Out>];
+type Result<P> = Expr<P, unknown, {
+    new: P;
+}>;
+type Update<P, Out> = (...args: Args<P, Out>) => Result<P>;
+type UpdateF<P, Out> = <K extends keyof IsDeleted>(...args: Args<Replace<P, RORec<K, Timestamp>>, Out>) => Result<Replace<P, RORec<K, Timestamp>>>;
+export declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert", update: Update<Replace<P, RORec<K, Timestamp>>, Out>) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
+export 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';
+};
+type MergeUpdate<V, Out> = UpdateF<((OPick<V, Allowed<StrKey<V>>> & ID) | (Rec<Allowed<StrKey<V>>, N> & ID)) & TS, Out>;
+export 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<EEE>, keyof (ND & TS)>, IdHKT>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
+export 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<EEE>, keyof (ND & TS)>, IdHKT>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Source, "out">;
+export 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", update?: MergeUpdate<V, Out>) => StreamRunnerParam<Source, "out">;
+export 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<EEE>, keyof (ND & TS)>, IdHKT>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Delta<SourcePart>, "out">;
+export 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>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Delta<SourcePart>, "out">;
+export {};

package/lib/aggregate/$upsert.d.ts

@@ -0,0 +1,19 @@
+import type { IdHKT, Replace, RWCollection } from '../../types';
+import type { ID, O, RORec, doc, rawItem } from '../../types/json';
+import { type ExprsExact } from '../expression/concat';
+import type { Del, Delta, Expr, StreamRunnerParam, TS } from '../types';
+import { type Exact } from '../utils/map-object';
+type ND = {
+    readonly deletedAt?: null;
+};
+type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
+export type Merge<T extends doc, E> = Omit<SafeE<E>, keyof (ND & TS)> & ((T & ND & TS) | Del);
+type ExprP<P> = Expr<P, unknown, {
+    new: P;
+}>;
+type Update<P, Out> = (added: ExprP<P>, old: Expr<Out, Out>) => ExprP<P>;
+export 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>, update?: Update<Replace<Merge<T, EEE>, {}>, Merge<T, EEE>>) => StreamRunnerParam<D, "out">;
+export declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
+export 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">;
+export declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
+export {};

package/lib/aggregate/group/$group-merge.d.ts

@@ -0,0 +1,18 @@
+import type { RWCollection, WriteonlyCollection } from '../../../types';
+import type { AsLiteral, ID, O, Rec, doc, notArr } from '../../../types/json';
+import { type ExprsExact } from '../../expression/concat';
+import type { Delta, DeltaAccumulators, Expr, StreamRunnerParam, TS } from '../../types';
+import type { MergeInto } from '../out';
+import { type Extra, type IdAndTsKeys, type Loose, type MergedInput, type Strict, type V_Grp } from './utils/sub-merge';
+type Denied<GID = never> = keyof (TS & ID) | GID;
+type GI<GG> = Exclude<GG, keyof TS>;
+export type GroupMergeOut<Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>> = MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, V, Grp, GG, EE>>>;
+export type GroupMergeCollection<WhenNotMatched extends MergeInto<never, never>['whenNotMatched'], Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>> = (GroupMergeOut<Grp, V, GG, EE, Out> & {
+    whenNotMatched: WhenNotMatched;
+})['into'];
+export 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: GroupMergeOut<Grp, V, GG, EE, Out>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
+export type GroupIdCollection<V extends O, EE = {}, Out extends Loose<string, V, '_id'> = Loose<string, V, '_id'>> = RWCollection<MergedInput<Out, V, string, '_id', EE>, Out>;
+export 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: GroupIdCollection<V, EE, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<Delta<T>, "out">;
+export type GroupCollection<Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, '_grp'> = Loose<Grp, V, '_grp'>> = RWCollection<MergedInput<Out, V, Grp, '_grp', EE> | Strict<Grp, V, '_grp', EE>, Out>;
+export 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: GroupCollection<Grp, V, 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">;
+export {};

package/lib/aggregate/group/index.d.ts

@@ -0,0 +1,3 @@
+export { $groupMerge, $groupId, $group } from './$group-merge';
+export type { GroupCollection, GroupIdCollection, GroupMergeCollection } from './$group-merge';
+export type { Loose, Strict, MergedInput } from './utils/sub-merge';

package/lib/aggregate/group/utils/sub-group.d.ts

@@ -0,0 +1,6 @@
+import type { O, RORec, Rec } from '../../../../types';
+import { type ExprsExact } from '../../../expression/concat';
+import type { Delta, Expr, RawStages } from '../../../types';
+import type { DeltaAccumulators } from '../../../types/accumulator';
+export type WithItem<V, Grp> = Rec<'_id', Grp> & Rec<'item', O<V>>;
+export declare const subGroup: <T extends O, Grp, V extends O, GID extends string>(id: Expr<Grp, T>, args: DeltaAccumulators<T, V>, addGrp: <D extends Rec<"_id", Grp>>(src: ExprsExact<V, D>) => ExprsExact<RORec<GID, Grp> & V, D>) => RawStages<unknown, Delta<T>, Rec<GID, Grp> & V>;

package/lib/aggregate/group/utils/sub-merge.d.ts

@@ -0,0 +1,20 @@
+import type { AsLiteral, ID, O, Rec, Replace, WriteonlyCollection, notArr } from '../../../../types';
+import { type ExprsExact } from '../../../expression/concat';
+import type { Model, RawStages, TS } from '../../../types';
+import type { DeltaAccumulators } from '../../../types/accumulator';
+import { type MergeInto } from '../../out';
+type GI<GG> = Exclude<GG, keyof TS>;
+export type IdAndTsKeys = keyof (TS & ID);
+type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI<GG>>;
+export type Prepare<Grp, GG extends string> = TS & ID & Rec<GI<GG>, Grp>;
+type Par<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+export type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
+export type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
+export type V_Grp<VV, GG extends string, Grp> = Rec<GI<GG>, Grp> & V<VV, GG>;
+export type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
+type OrReplace<T, V> = T | Replace<T, V>;
+export 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>>;
+export declare const subMerge: <T extends O, Grp extends notArr, VV extends O, GG extends string, EE = {}, Out extends Loose<Grp, VV, GG> = Loose<Grp, VV, GG>>(args: DeltaAccumulators<T, V<VV, GG>>, out: MergeInto<Strict<Grp, VV, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, VV, Grp, GG, EE>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, VV, GG>, V_Grp<VV, GG, Grp>>, idPrefix: string, first: boolean) => RawStages<unknown, V_Grp<VV, GG, Grp>, "out">;
+export {};

package/lib/aggregate/index.d.ts

@@ -0,0 +1,10 @@
+export { emptyDelta } from './prefix';
+export * from './group';
+export * from './lookup';
+export * from './match';
+export * from './set';
+export * from './unwind';
+export * from './$merge';
+export * from './$upsert';
+export * from './out';
+export { $group_ } from './mongo-stages';

package/lib/aggregate/lookup/$lookup-delta.d.ts

@@ -0,0 +1,11 @@
+import type { Arr, AsLiteral, ID, N, O, Rec, doc, rawItem } from '../../../types';
+import { Field } from '../../field';
+import type { BA, Before, Delta, RawStages, TStages, UBefore } from '../../types';
+import { type JoinId } from '../unwind';
+type s = string;
+type Both<K1 extends s, LE, KK2 extends s, RE, N1 extends null = never, N2 extends null = never> = Delta<Rec<K1, LE | N1> & Rec<Exclude<KK2, BA | K1>, RE | N2> & ID>;
+export declare const $lookupDelta: <LQ extends O, LE extends LQ & doc, RQ extends O, RE extends RQ & doc, BRB extends UBefore<RQ>, RS extends UBefore<RQ>, S extends rawItem, K1 extends s, KK2 extends s, N1 extends null = never, N2 extends null = never>({ field1, field2 }: {
+    field1: Field<LQ, S | N | Arr<S>>;
+    field2: Field<RQ, S | N | Arr<S>>;
+}, { coll, exec, input }: TStages<RS, UBefore<RQ>, BRB, Before<RE>>, k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, BA | K1>>, k: JoinId<K1, Exclude<KK2, BA | K1>>, includeNull1?: N1, includeNull2?: N2) => RawStages<unknown, Delta<LE>, Both<K1, LE, KK2, RE, N1, N2>>;
+export {};

package/lib/aggregate/lookup/$lookup-raw.d.ts

@@ -0,0 +1,10 @@
+import type { App, Arr, AsLiteral, HKT, ID, O, Rec, rawItem } from '../../../types';
+import { type Field } from '../../field';
+import type { Before, RawStages, TStages, UBefore } from '../../types';
+import { type JoinId } from '../unwind';
+type s = string;
+export declare const $lookupRaw: <LQ extends O, LE extends LQ & ID, RQ extends O, RE extends RQ & ID, BRB extends Before<RQ>, RS extends UBefore<RQ>, S extends rawItem, As extends s, Null extends null = never>({ field1, field2 }: {
+    field1: Field<LQ, S | Arr<S>>;
+    field2: Field<RQ, S | Arr<S>>;
+}, { coll, exec, input }: TStages<RS, Before<RQ>, BRB, Before<RE>>, k2: AsLiteral<As>, k: JoinId<"left", "right">, includeNull?: Null) => <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, LQ>, App<F, LE>, App<F, LE & Rec<As, RE | Null> & ID>>;
+export {};

package/lib/aggregate/lookup/index.d.ts

@@ -0,0 +1,20 @@
+import { type AsLiteral, type O, type RORec, type doc, type notArr, type Arr, type N } from '../../../types';
+import { type Field } from '../../field';
+import type { SnapshotStream, SnapshotStreamExecutionResult } from '../../types/stream';
+type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
+    from: SnapshotStreamExecutionResult<RQ, RE>;
+    as: AsLiteral<As>;
+} & ({
+    to: 'one';
+    localField: Field<LQ, string | N>;
+    foreignField?: never;
+    middle?: never;
+} | {
+    to: 'many';
+    middle: string;
+    localField: Field<LQ, S | Arr<S>>;
+    foreignField: Field<RQ, S | Arr<S>>;
+});
+export declare const $lookup: <As extends string, LQ extends doc, RQ extends doc, 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>>;
+export declare const $outerLookup: <As extends string, LQ extends doc, RQ extends doc, 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>>;
+export {};

package/lib/aggregate/match/$match-delta.d.ts

@@ -0,0 +1,4 @@
+import type { doc } from '../../../types';
+import type { Delta, Expr, RawStages } from '../../types';
+export declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
+export declare const matchDelta: <D>() => RawStages<unknown, Delta<D | null>, Delta<D>>;

package/lib/aggregate/match/$match.d.ts

@@ -0,0 +1,3 @@
+import type { doc } from '../../../types';
+import type { DeltaStages, Expr } from '../../types';
+export declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;

package/lib/aggregate/match/index.d.ts

@@ -0,0 +1,2 @@
+export { $matchDelta, matchDelta } from './$match-delta';
+export { $match } from './$match';