@omegup/msync 0.1.7 → 0.1.9

package/index.d.ts

@@ -106,13 +106,15 @@ type Stream<out Q extends O, in out T extends Q, in out F extends HKT<[O, O]>, i
 type TS = {
     readonly touchedAt: Timestamp;
 };
-type DDel = {
+type IsDeleted = {
     readonly deletedAt: Timestamp;
-} & ID & TS;
+};
+type DDel = IsDeleted & ID & TS;
 type Del = O<DDel>;
-type D = O<{
+type DeletedAt = {
     readonly deletedAt?: Timestamp | null | undefined;
-} & ID>;
+};
+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;
@@ -431,7 +433,7 @@ type MergeArgs<T extends O, Out extends O, Ctx, In extends O> = {
     stages: true;
     into: RWCollection<In, Out>;
     whenMatched: RawStages<unknown, Out, In, {
-        new: In;
+        new: T;
     }>;
 } | {
     stages: 'ctx';
@@ -503,11 +505,19 @@ type ND$1 = {
     readonly deletedAt?: null;
 };
 type SafeE$1<E> = Omit<E, `$${string}` | keyof ID>;
-declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends doc, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: RWCollection<Out | Replace<Out, Patch<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>, whenNotMatched: "fail" | "discard") => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
-declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched: "fail" | "discard", 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 doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Source, "out">;
-declare const $mergePart: <V extends O>() => <Out extends doc, 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>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Delta<SourcePart>, "out">;
-declare const $merge: <V extends O>() => <Out extends doc, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Delta<SourcePart>, "out">;
+declare const getWhenMatched: <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>>>>;
+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;
@@ -519,6 +529,17 @@ declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) =>
 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"];
+}, indexSpec: IndexSpecification, options?: 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>> = {
@@ -608,7 +629,7 @@ 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_0: Expr<T1 | N, D, C>, exprs_1: Expr<T2, D, C>) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
+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>;
@@ -706,19 +727,8 @@ declare const $and: Combiner;
 declare const $nor: Combiner;
 declare const $or: Combiner;
 
-declare const log: (...args: unknown[]) => void;
-
-declare const createIndex: (collection: {
-    readonly createIndex: Collection["createIndex"];
-}, indexSpec: IndexSpecification, options?: 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 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, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type MongoTypeNames, type N, type NoRaw, type NullToOBJ, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, type jsonItem, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, type notArr, 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 { $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, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, type ExactKeys, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type MongoTypeNames, type N, type NoRaw, type NullToOBJ, type O, type OPick, type OPickD, type Patch, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, gt, gte, inArray, isArray, ite, type jsonPrim, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, type notArr, 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 };

package/index.esm.js

@@ -1365,84 +1365,88 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeX = (out, keys, f, map, whenNotMatched = 'fail', ext) => {
+const getWhenMatched = (whenNotMatched) => {
+    const setDeleted = whenNotMatched === 'discard';
+    const orNull = (e) => (setDeleted ? $ifNull(e, nil) : e);
+    const preMergeOld = setDeleted
+        ? mergeObjects(root().of('old').expr(), field({
+            deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
+            touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
+        }))
+        : root().of('old').expr();
+    const same = eq(preMergeOld)(root().of('merged').expr());
+    const newOrOld = whenNotMatched ===
+        'insert'
+        ? ctx()('new')
+        : root();
+    const merged = mergeObjects(root().expr(), ctx()('new').expr(), field({
+        deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
+    }));
+    return link()
+        .with($replaceWith_(field({
+        old: ['old', root().expr()],
+        merged: ['merged', merged],
+    })))
+        .with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
+};
+const $mergeX = (out, keys, f, map, ext) => {
     const patch = mapExact(keys, v => sub(v, f));
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
-    const setDeleted = whenNotMatched === 'discard';
+    const setDeleted = out.whenNotMatched === 'discard';
     const replacer = map(field(omitPick().backward(spread(patch, {
         _id: ['_id', f.of('_id').expr()],
         touchedAt: ['touchedAt', current],
-        deletedAt: [setDeleted ? 'deletedAt' : 'touchedAt', current],
     }))));
-    return {
-        raw: (first) => link()
-            .with($replaceWith_(replacer))
+    const sss = setDeleted
+        ? link()
+            .with($set_(set()({
+            deletedAt: ['deletedAt', to(current)],
+        })))
             .with($merge_({
-            into: out,
+            into: out.coll,
+            on: root().of('_id'),
+            whenNotMatched: 'insert',
+            stages: true,
+            whenMatched: getWhenMatched(out.whenNotMatched),
+        })).stages
+        : link().with($merge_({
+            into: out.coll,
             on: root().of('_id'),
-            whenNotMatched: whenNotMatched === 'fail' ? 'fail' : 'insert',
+            whenNotMatched: 'fail',
             stages: true,
-            whenMatched: asStages([
+            whenMatched: getWhenMatched(out.whenNotMatched),
+        })).stages;
+    const teardown = (coll) => ({
+        collection: coll,
+        method: 'updateMany',
+        params: [
+            filter,
+            [
                 {
-                    $replaceWith: {
-                        old: '$$ROOT',
-                        merged: {
-                            $mergeObjects: [
-                                '$$ROOT',
-                                '$$new',
-                                ...(setDeleted ? [{ deletedAt: { $ifNull: ['$deletedAt', null] } }] : []),
-                            ],
-                        },
-                    },
+                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
                 },
-                {
-                    $replaceWith: {
-                        $cond: {
-                            if: {
-                                $eq: [
-                                    {
-                                        $mergeObjects: [
-                                            '$old',
-                                            { deletedAt: { $ifNull: ['$old.deletedAt', null] } },
-                                        ],
-                                    },
-                                    { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
-                                ],
-                            },
-                            then: '$old',
-                            else: '$merged',
-                        },
-                    },
-                },
-            ]),
-        })).stages,
-        teardown: c => c({
-            collection: out,
-            method: 'updateMany',
-            params: [
-                filter,
-                [
-                    {
-                        $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                    },
-                ],
             ],
-        }),
+        ],
+    });
+    return {
+        raw: (first) => link().with($replaceWith_(replacer)).with(sss)
+            .stages,
+        teardown: c => (setDeleted ? c(teardown(out.coll)) : c(teardown(out.coll))),
     };
 };
-const $mergeId = () => (out, keys, id, ext, whenNotMatched) => {
+const $mergeId = () => (out, keys, id, ext) => {
     const omRORec = omitRORec();
     return $mergeX(out, keys, root().of('after'), or => {
         return ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
             _id: ['_id', id],
             touchedAt: ['touchedAt', current],
         }))), or);
-    }, whenNotMatched, ext);
+    }, ext);
 };
-const $simpleMergePart = () => (out, keys, whenNotMatched, ext) => $mergeX(out, keys, root(), id$1, whenNotMatched, ext);
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX(out, keys, root(), id$1, whenNotMatched, {});
-const $mergePart = () => (out, keys, ext, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext, whenNotMatched);
-const $merge = () => (out, keys, whenNotMatched = 'fail') => $mergePart()(out, keys, {}, whenNotMatched);
+const $simpleMergePart = () => (out, keys, ext) => $mergeX(out, keys, root(), id$1, ext);
+const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {});
+const $mergePart = () => (out, keys, ext) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext);
+const $merge = () => (out, keys) => $mergePart()(out, keys, {});
 const assertNotNull$1 = (expr) => expr;
 
 const $insertX = (out, expr, map, ext, extExpr) => {
@@ -1467,23 +1471,7 @@ const $insertX = (out, expr, map, ext, extExpr) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: asStages([
-                    { $replaceWith: { old: '$$ROOT', merged: { $mergeObjects: ['$$ROOT', '$$new'] } } },
-                    {
-                        $replaceWith: {
-                            $cond: {
-                                if: {
-                                    $eq: [
-                                        '$old',
-                                        { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
-                                    ],
-                                },
-                                then: '$old',
-                                else: '$merged',
-                            },
-                        },
-                    },
-                ]),
+                whenMatched: getWhenMatched('insert'),
                 whenNotMatched: 'insert',
             })).stages;
         },
@@ -2007,4 +1995,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-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, Field, Machine, add, and, anyElementTrue, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, 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 { $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, Field, Machine, add, and, anyElementTrue, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, getWhenMatched, 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 };

package/index.js

@@ -1367,84 +1367,88 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeX = (out, keys, f, map, whenNotMatched = 'fail', ext) => {
+const getWhenMatched = (whenNotMatched) => {
+    const setDeleted = whenNotMatched === 'discard';
+    const orNull = (e) => (setDeleted ? $ifNull(e, nil) : e);
+    const preMergeOld = setDeleted
+        ? mergeObjects(root().of('old').expr(), field({
+            deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
+            touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
+        }))
+        : root().of('old').expr();
+    const same = eq(preMergeOld)(root().of('merged').expr());
+    const newOrOld = whenNotMatched ===
+        'insert'
+        ? ctx()('new')
+        : root();
+    const merged = mergeObjects(root().expr(), ctx()('new').expr(), field({
+        deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
+    }));
+    return link()
+        .with($replaceWith_(field({
+        old: ['old', root().expr()],
+        merged: ['merged', merged],
+    })))
+        .with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
+};
+const $mergeX = (out, keys, f, map, ext) => {
     const patch = mapExact(keys, v => sub(v, f));
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
-    const setDeleted = whenNotMatched === 'discard';
+    const setDeleted = out.whenNotMatched === 'discard';
     const replacer = map(field(omitPick().backward(spread(patch, {
         _id: ['_id', f.of('_id').expr()],
         touchedAt: ['touchedAt', current],
-        deletedAt: [setDeleted ? 'deletedAt' : 'touchedAt', current],
     }))));
-    return {
-        raw: (first) => link()
-            .with($replaceWith_(replacer))
+    const sss = setDeleted
+        ? link()
+            .with($set_(set()({
+            deletedAt: ['deletedAt', to(current)],
+        })))
             .with($merge_({
-            into: out,
+            into: out.coll,
+            on: root().of('_id'),
+            whenNotMatched: 'insert',
+            stages: true,
+            whenMatched: getWhenMatched(out.whenNotMatched),
+        })).stages
+        : link().with($merge_({
+            into: out.coll,
             on: root().of('_id'),
-            whenNotMatched: whenNotMatched === 'fail' ? 'fail' : 'insert',
+            whenNotMatched: 'fail',
             stages: true,
-            whenMatched: asStages([
+            whenMatched: getWhenMatched(out.whenNotMatched),
+        })).stages;
+    const teardown = (coll) => ({
+        collection: coll,
+        method: 'updateMany',
+        params: [
+            filter,
+            [
                 {
-                    $replaceWith: {
-                        old: '$$ROOT',
-                        merged: {
-                            $mergeObjects: [
-                                '$$ROOT',
-                                '$$new',
-                                ...(setDeleted ? [{ deletedAt: { $ifNull: ['$deletedAt', null] } }] : []),
-                            ],
-                        },
-                    },
+                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
                 },
-                {
-                    $replaceWith: {
-                        $cond: {
-                            if: {
-                                $eq: [
-                                    {
-                                        $mergeObjects: [
-                                            '$old',
-                                            { deletedAt: { $ifNull: ['$old.deletedAt', null] } },
-                                        ],
-                                    },
-                                    { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
-                                ],
-                            },
-                            then: '$old',
-                            else: '$merged',
-                        },
-                    },
-                },
-            ]),
-        })).stages,
-        teardown: c => c({
-            collection: out,
-            method: 'updateMany',
-            params: [
-                filter,
-                [
-                    {
-                        $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                    },
-                ],
             ],
-        }),
+        ],
+    });
+    return {
+        raw: (first) => link().with($replaceWith_(replacer)).with(sss)
+            .stages,
+        teardown: c => (setDeleted ? c(teardown(out.coll)) : c(teardown(out.coll))),
     };
 };
-const $mergeId = () => (out, keys, id, ext, whenNotMatched) => {
+const $mergeId = () => (out, keys, id, ext) => {
     const omRORec = omitRORec();
     return $mergeX(out, keys, root().of('after'), or => {
         return ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
             _id: ['_id', id],
             touchedAt: ['touchedAt', current],
         }))), or);
-    }, whenNotMatched, ext);
+    }, ext);
 };
-const $simpleMergePart = () => (out, keys, whenNotMatched, ext) => $mergeX(out, keys, root(), id$1, whenNotMatched, ext);
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX(out, keys, root(), id$1, whenNotMatched, {});
-const $mergePart = () => (out, keys, ext, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext, whenNotMatched);
-const $merge = () => (out, keys, whenNotMatched = 'fail') => $mergePart()(out, keys, {}, whenNotMatched);
+const $simpleMergePart = () => (out, keys, ext) => $mergeX(out, keys, root(), id$1, ext);
+const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {});
+const $mergePart = () => (out, keys, ext) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext);
+const $merge = () => (out, keys) => $mergePart()(out, keys, {});
 const assertNotNull$1 = (expr) => expr;
 
 const $insertX = (out, expr, map, ext, extExpr) => {
@@ -1469,23 +1473,7 @@ const $insertX = (out, expr, map, ext, extExpr) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: asStages([
-                    { $replaceWith: { old: '$$ROOT', merged: { $mergeObjects: ['$$ROOT', '$$new'] } } },
-                    {
-                        $replaceWith: {
-                            $cond: {
-                                if: {
-                                    $eq: [
-                                        '$old',
-                                        { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
-                                    ],
-                                },
-                                then: '$old',
-                                else: '$merged',
-                            },
-                        },
-                    },
-                ]),
+                whenMatched: getWhenMatched('insert'),
                 whenNotMatched: 'insert',
             })).stages;
         },
@@ -2096,6 +2084,7 @@ exports.firstSure = firstSure;
 exports.floor = floor;
 exports.from = from;
 exports.func = func;
+exports.getWhenMatched = getWhenMatched;
 exports.gt = gt;
 exports.gte = gte;
 exports.inArray = inArray;

package/lib/accumulators/index.d.ts

@@ -0,0 +1,10 @@
+import type { AppMap, Arr, N, O, Rec } from '../../types';
+import type { ExprHKT } from '../expression/concat';
+import { type NoRaw } from '../expression/val';
+import type { DeltaAccumulator, Expr, Part } from '../types';
+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: () => 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>;
+export declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
+export 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>;
+export declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
+export 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>;

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

@@ -0,0 +1,27 @@
+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>;
+export declare const getWhenMatched: <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>>>>;
+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';
+};
+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>) => 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>) => 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") => 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>) => 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>) => StreamRunnerParam<Delta<SourcePart>, "out">;
+export {};

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

@@ -0,0 +1,15 @@
+import type { IdHKT, 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);
+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>) => 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,12 @@
+import type { RWCollection, WriteonlyCollection } from '../../../types';
+import type { AsLiteral, ID, O, Rec, Replace, 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 Strict, type V_Grp } from './utils/sub-merge';
+type Denied<GID = never> = keyof (TS & ID) | GID;
+type GI<GG> = Exclude<GG, keyof TS>;
+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: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, V, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "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: RWCollection<Replace<Out, Strict<string, V, "_id", EE>>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<Delta<T>, "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: RWCollection<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">;
+export {};

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

@@ -0,0 +1,2 @@
+export { $groupMerge, $groupId, $group } from './$group-merge';
+export type { Loose, Strict } 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,18 @@
+import type { AsLiteral, ID, O, Rec, Replace, WriteonlyCollection, notArr } from '../../../../types';
+import { type ExprsExact } from '../../../expression/concat';
+import type { 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>>;
+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<Replace<Out, Strict<Grp, VV, 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,9 @@
+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,10 @@
+import type { AsLiteral, ID, N, O, Rec, doc, rawItem } from '../../../types';
+import { Field } from '../../field';
+import type { BA, Before, Delta, RawStages, TStages, UBefore } from '../../types';
+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>;
+    field2: Field<RQ, S | N>;
+}, { coll, exec, input }: TStages<RS, UBefore<RQ>, BRB, Before<RE>>, k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, BA | K1>>, k: ([N1] extends [never] ? K1 : never) | ([N2] extends [never] ? Exclude<KK2, BA | K1> : never) | false, 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,9 @@
+import type { App, AsLiteral, HKT, ID, O, Rec } from '../../../types';
+import { type Field } from '../../field';
+import type { Before, RawStages, TStages } from '../../types';
+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, S, As extends s, Null extends null = never>({ field1, field2 }: {
+    field1: Field<LQ, S>;
+    field2: Field<RQ, S>;
+}, { coll, exec, input }: TStages<RS, Before<RQ>, BRB, Before<RE>>, k2: AsLiteral<As>, k: "left", 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> & ID>>;
+export {};

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

@@ -0,0 +1,12 @@
+import type { AsLiteral, O, RORec, doc, notArr } 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> = {
+    localField: Field<LQ, S>;
+    foreignField: Field<RQ, S>;
+    from: SnapshotStreamExecutionResult<RQ, RE>;
+    as: AsLiteral<As>;
+};
+export 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>>;
+export 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>>;
+export {};