@omegup/msync 0.1.53 → 0.1.55

package/index.d.ts

@@ -168,10 +168,8 @@ 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 DeletedFlags = O<{
-    readonly before?: true;
-    readonly after?: true;
-}>;
+type NTrue = true | N;
+type DeletedFlags = Rec<BA, NTrue>;
 type Deleted = {
     readonly deleted?: DeletedFlags;
 };
@@ -245,7 +243,7 @@ declare const mapExact1: <K extends s$3, F extends HKT<K>, G extends HKT<K>>(x:
 declare const mapExactToObject: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<StrKey<T>>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, P>) => ExactPart1<T, G>;
 declare const mapExact: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<T[StrKey<T>]>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, T[P]>) => Exact<T, G>;
 type Dom$1<T, V> = HKT<T[StrKey<T>] | V[StrKey<V>]>;
-declare const spread: <T, V, F extends Dom$1<T, V>, E = unknown, No extends keyof V = never>(a: Exact<Omit<T, No>, F>, b: Exact<V, F>) => Exact<V & Omit<T, keyof V> & Pick<E, symbol & keyof E>, F>;
+declare const spread: <T, V, F extends Dom$1<T, V>, EK extends symbol = never, EE = unknown, No extends keyof V = never>(a: Exact<Omit<T, No>, F>, b: Exact<V, F>) => Exact<V & Omit<T, keyof V> & Record<EK, EE>, F>;
 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>>;
 }
@@ -291,10 +289,10 @@ declare const fieldM: <M extends RORec<Dom, Ref>, T extends RORec<Ref, unknown>,
 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>;
+declare const mergeExact: <T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>, EK extends symbol = never, EE = unknown>(exprsExact1: Exact<Omit<T1, keyof T2>, F>, exprsExact2: Exact<T2, F>) => Exact<T2 & Omit<T1, keyof T2> & Record<EK, EE>, 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>;
+declare const mergeExpr: <T1, T2, D, C = unknown, EK extends symbol = never, EE = 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> & Record<EK, EE>, 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>;
@@ -303,7 +301,6 @@ type ExprsExact<T, D, C = unknown, F extends HKT = IdHKT> = Exact<T, ExprHKT<D,
 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>;
 
@@ -471,7 +468,6 @@ declare const renamedFields: <K extends s$2, F extends HKT<K, s$2>, G extends HK
 declare const translateOmit: <T, K extends string, Q extends string, P extends string>() => Equal<unknown, Omit<Omit<T, K | Q>, P>, Omit<Omit<T, K | Q>, Q | P>>;
 declare const excludeIdem: <K extends s$2, E extends s$2, S extends E = E>() => Equal<Exclude<K, E>, Exclude<K, E>, Exclude<Exclude<K, E>, S>>;
 declare const eqPar: <K extends string, T extends Rec<K, jsonItem>, K2 extends K>() => Equal<unknown, Par$1<K2, T>, Par$1<K, T>>;
-declare const notExtendExcluded: <Key extends keyof any, Others extends keyof any, Source extends keyof any, Denied extends keyof any, F extends HKT<Others | Exclude<Source, Denied | Key>, Dom>, Else extends Dom, Dom = unknown>() => Equal<Dom, Key extends Others | Exclude<Source, Key | Denied> ? App<F, Key> : Else, Key extends Others ? App<F, Key> : Else>;
 
 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>;
@@ -548,7 +544,7 @@ type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S exte
     as: AsLiteral<As>;
 } & ({
     to: 'one';
-    localField: Field<LQ, string>;
+    localField: Field<LQ, string | N>;
     foreignField?: never;
     middle?: never;
 } | {
@@ -588,7 +584,7 @@ declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => Delt
 type s$1 = string;
 type JoinId<K1 extends s$1, K2 extends s$1> = K1 | K2 | readonly [K1, middle: s$1, K2] | readonly [K2, middle: s$1, K1];
 declare const joinIdOf: <K1 extends s$1, K2 extends s$1, D, C = unknown>(k: JoinId<K1, K2>, k1: K1, k1Id: Expr<s$1, D, C>, k2Id: Expr<s$1, D, C>) => Expr<s$1, D, C>;
-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: JoinId<K1, K2>, includeNull1?: N1, includeNull2?: N2) => RawStages<unknown, Delta<Rec<K1, T | N1> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T | N1> & Rec<K2, U | N2> & ID>>;
+declare const $unwindDelta: <K1 extends s$1, T extends doc, KK2 extends s$1, U extends doc, N1 extends null = never, N2 extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, K1 | BA>>, k: JoinId<K1, Exclude<KK2, K1 | BA>>, includeNull1?: N1, includeNull2?: N2) => RawStages<unknown, Delta<Rec<K1, T | N1> & Rec<Exclude<KK2, K1 | BA>, Arr<U>>>, Delta<Rec<K1, T | N1> & Rec<Exclude<KK2, K1 | BA>, U | N2> & ID>>;
 
 type s = string;
 type TOf<TT, K extends string> = doc & Omit<TT, K>;
@@ -693,12 +689,12 @@ declare const gt: {
     <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>;
+    <D, C>(...expr: [Expr<Date | N, D, C>, Expr<Date | N, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number | N, D, C>, Expr<number | N, 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>;
+    <D, C>(...expr: [Expr<Date | N, D, C>, Expr<Date | N, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number | N, D, C>, Expr<number | N, 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>;
@@ -775,7 +771,10 @@ declare const sub: <T, D, Ctx, P extends O>(a: Expr<T, D, Ctx>, f: Field<P, D, C
 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 $ifNull: {
+    <R, D, C = unknown>(...expr: [...Expr<R | null | undefined, D, C>[], Expr<R, D, C>]): Expr<R, D, C>;
+    <R, D, C = unknown>(...expr: [Expr<R, D, C>, ...Expr<R | null | undefined, 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, }: {
@@ -842,5 +841,5 @@ declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Pr
 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, $countDictArray, $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, $substr, $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, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notExtendExcluded, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, pair, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $countDictArray, $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, $substr, $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, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };
 export type { Accumulators, AddO, And, App, AppMap, AppMapRW, ApplyHKT, Arr, ArrHKT, AsLiteral, ConstHKT, DeepFieldHKT, Delta, DeltaAccumulator, DeltaAccumulatorHKT, DeltaAccumulators, DeltaStages, Equal, Exact, ExactKeys, ExactPart, ExactPart1, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, FieldHKT, GroupCollection, GroupIdCollection, GroupMergeCollection, HKT, I, ID, IdHKT, JoinId, Loose, MapK, MapKDom, MapKPart1, MapO, MapOPart, MappedHKT, Merge, MergeArgs, MergeHKT, MergeInto, MergeMapOArgs, MergedInput, Model, MongoTypeNames, N, NullToOBJ, O, OPick, OPickD, Patch, PromiseHKT, RConstHKT, RORec, RWCollection, RawStages, Rec, RecHKT, RecordHKT, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, UBeforeHKT, WithKey1, WriteonlyCollection, doc, jsonPrim, notArr, µ };

package/index.esm.js

@@ -400,8 +400,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())),
@@ -437,7 +435,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() }),
@@ -945,7 +942,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, {
@@ -1162,48 +1161,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',
@@ -1213,154 +1176,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 = '.') => {
@@ -1397,7 +1338,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',
@@ -1419,15 +1363,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;
@@ -2474,4 +2424,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-export { $accumulator, $and, $countDict, $countDictArray, $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, $substr, $sum, $type, $unwind, $unwindDelta, Field, Machine, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notExtendExcluded, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, pair, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $countDictArray, $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, $substr, $sum, $type, $unwind, $unwindDelta, Field, Machine, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };