@omegup/msync 0.1.59 → 0.1.61

package/index.d.ts

@@ -606,8 +606,9 @@ type Result<P> = Expr<P, unknown, {
 }>;
 type Update$1<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>>>;
-declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert", update: Update$1<Replace<P, RORec<K, Timestamp>>, Out>) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
-declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Rec<"old" | "merged", Out | Replace<Out, P>>, Out | Replace<Out, P>>;
+declare const getSubsetMatchForExt: <Out extends Model, P extends Model, E extends Record<keyof E, rawItem>>(ext: Exact<E, IdHKT>) => null | Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>>;
+declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert", update: Update$1<Replace<P, RORec<K, Timestamp>>, Out>, canWrite: Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>> | null) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
+declare const getWhenMatched: <Out extends Model, P extends Model>(whenNotMatched: "discard" | "fail" | "insert", canWrite: Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>> | null) => 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';
@@ -632,7 +633,7 @@ type ExprP<P> = Expr<P, unknown, {
 }>;
 type Update<P, Out> = (added: ExprP<P>, old: Expr<Out, Out>) => ExprP<P>;
 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">;
-declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
+declare const $simpleInsert: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<T, "out">;
 declare const $insertPart: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Delta<T>, "out">;
 declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
 
@@ -770,7 +771,7 @@ declare const not: <D, C = unknown>(expr: Expr<boolean, D, C>) => Expr<boolean,
 declare const eq: <T, D, C = unknown>(a: Expr<T, D, C>) => (b: Expr<T, D, C>) => Expr<boolean, D, C>;
 declare const sub: <T, D, Ctx, P extends O>(a: Expr<T, D, Ctx>, f: Field<P, D, Ctx>) => Expr<T, P, Ctx>;
 declare const eqTyped: <T1 extends Dom, T2 extends Dom, F extends HKT<Dom>, C = unknown, Dom = unknown>(a: Expr<T1 | T2, App<F, T1 | T2>, C>, b: Expr<T1, App<F, T1 | T2>, C>) => BoolExpr<App<F, T1>, App<F, T2>, C>;
-declare const ne: <T, D, C>(a: Expr<T, D, C>) => <K>(b: Expr<K, D, C>) => Expr<boolean, D, C>;
+declare const ne: <T, D, C = unknown>(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 = unknown>(...expr: [...Expr<R | null | undefined, D, C>[], Expr<R, D, C>]): Expr<R, D, C>;
@@ -842,5 +843,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, min, 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 { $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, getSubsetMatchForExt, 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, min, 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, GroupMergeOut, 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

@@ -919,7 +919,17 @@ const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
 ]);
 const $merge2 = (args) => $merge_(args);
 
-const getWhenMatchedForMerge = (whenNotMatched, update) => {
+const getSubsetMatchForExt = (ext) => {
+    const extObj = mapExactToObject(ext, (v, k) => {
+        return eq(root()
+            .of('old')
+            .of(k)
+            .expr())(val(v));
+    });
+    const checks = Object.values(extObj);
+    return checks.length ? (checks.length === 1 ? checks[0] : and(...checks)) : null;
+};
+const getWhenMatchedForMerge = (whenNotMatched, update, canWrite) => {
     const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
     const newOrOld = whenNotMatched ===
         'insert'
@@ -933,22 +943,24 @@ const getWhenMatchedForMerge = (whenNotMatched, update) => {
         old: ['old', root().expr()],
         merged: ['merged', merged],
     })))
-        .with(getWhenMatched(whenNotMatched)).stages;
+        .with(getWhenMatched(whenNotMatched, canWrite)).stages;
 };
-const getWhenMatched = (whenNotMatched) => {
+const getWhenMatched = (whenNotMatched, canWrite) => {
     const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
     const preMergeOld = mergeObjects(root().of('old').expr(), field({
         deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
         touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
     }));
-    const same = eq(preMergeOld)(root().of('merged').expr());
-    return link().with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
+    const diff = ne(preMergeOld)(root().of('merged').expr());
+    const useNew = canWrite ? and(diff, canWrite) : diff;
+    return link().with($replaceWith_(ite(useNew, root().of('merged').expr(), root().of('old').expr()))).stages;
 };
 const $mergeX = (out, keys, f, map, ext, update) => {
     const patch = mapExact(keys, (v) => {
         return $ifNull(sub(v, f), nil);
     });
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    const sameSubset = getSubsetMatchForExt(ext);
     const setDeleted = out.whenNotMatched === 'discard';
     const replacer = map(field(omitPick().backward(spread(patch, {
         _id: ['_id', f.of('_id').expr()],
@@ -964,14 +976,14 @@ const $mergeX = (out, keys, f, map, ext, update) => {
             on: root().of('_id'),
             whenNotMatched: 'insert',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update, sameSubset),
         })).stages
         : link().with($merge_({
             into: out.coll,
             on: root().of('_id'),
             whenNotMatched: 'fail',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update, sameSubset),
         })).stages;
     const teardown = (coll) => ({
         collection: coll,
@@ -1032,7 +1044,7 @@ const subMerge = (args, out, gid, extra, idPrefix, first) => {
         touchedAt: ['touchedAt', to(current)],
     };
     const updater = set()(addTSAndExtra);
-    const whenMatched = getWhenMatched(out.whenNotMatched);
+    const whenMatched = getWhenMatched(out.whenNotMatched, null);
     return link()
         .with($set_(set()(addExtraAndMerge)))
         .with($merge_({
@@ -1698,6 +1710,7 @@ const $replaceWith = (expr) => ({
 
 const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    const sameSubset = getSubsetMatchForExt(ext);
     return {
         teardown: c => c({
             collection: out,
@@ -1718,13 +1731,16 @@ const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: getWhenMatchedForMerge('insert', update),
+                whenMatched: getWhenMatchedForMerge('insert', update, sameSubset),
                 whenNotMatched: 'insert',
             })).stages;
         },
     };
 };
-const $simpleInsert = (out) => $insertX(out, root().expr(), id$1, {}, {});
+const $simpleInsert = (out, ext) => {
+    const extExpr = mapExact(ext, (v) => val(v));
+    return $insertX(out, root().expr(), id$1, ext, extExpr);
+};
 const $insertPart = (out, ext) => {
     const extExpr = mapExact(ext, (v) => val(v));
     return $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field(mergeExpr(translateOmit().forward(extExpr), {
@@ -2179,7 +2195,6 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
                     .with(input.delta)
                     .with(stages).stages,
             }), false, start);
-            stages.at(-1).$merge.into.coll;
             return next(step5({ ts: result.cursor.atClusterTime, aggResult, stream, nextRes, first }), 'remove handled deleted updated');
         };
         const step5 = (l) => async () => {
@@ -2427,4 +2442,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, min, 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 { $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, getSubsetMatchForExt, 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, min, 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 };

package/index.js

@@ -921,7 +921,17 @@ const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
 ]);
 const $merge2 = (args) => $merge_(args);
 
-const getWhenMatchedForMerge = (whenNotMatched, update) => {
+const getSubsetMatchForExt = (ext) => {
+    const extObj = mapExactToObject(ext, (v, k) => {
+        return eq(root()
+            .of('old')
+            .of(k)
+            .expr())(val(v));
+    });
+    const checks = Object.values(extObj);
+    return checks.length ? (checks.length === 1 ? checks[0] : and(...checks)) : null;
+};
+const getWhenMatchedForMerge = (whenNotMatched, update, canWrite) => {
     const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
     const newOrOld = whenNotMatched ===
         'insert'
@@ -935,22 +945,24 @@ const getWhenMatchedForMerge = (whenNotMatched, update) => {
         old: ['old', root().expr()],
         merged: ['merged', merged],
     })))
-        .with(getWhenMatched(whenNotMatched)).stages;
+        .with(getWhenMatched(whenNotMatched, canWrite)).stages;
 };
-const getWhenMatched = (whenNotMatched) => {
+const getWhenMatched = (whenNotMatched, canWrite) => {
     const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
     const preMergeOld = mergeObjects(root().of('old').expr(), field({
         deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
         touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
     }));
-    const same = eq(preMergeOld)(root().of('merged').expr());
-    return link().with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
+    const diff = ne(preMergeOld)(root().of('merged').expr());
+    const useNew = canWrite ? and(diff, canWrite) : diff;
+    return link().with($replaceWith_(ite(useNew, root().of('merged').expr(), root().of('old').expr()))).stages;
 };
 const $mergeX = (out, keys, f, map, ext, update) => {
     const patch = mapExact(keys, (v) => {
         return $ifNull(sub(v, f), nil);
     });
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    const sameSubset = getSubsetMatchForExt(ext);
     const setDeleted = out.whenNotMatched === 'discard';
     const replacer = map(field(omitPick().backward(spread(patch, {
         _id: ['_id', f.of('_id').expr()],
@@ -966,14 +978,14 @@ const $mergeX = (out, keys, f, map, ext, update) => {
             on: root().of('_id'),
             whenNotMatched: 'insert',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update, sameSubset),
         })).stages
         : link().with($merge_({
             into: out.coll,
             on: root().of('_id'),
             whenNotMatched: 'fail',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update, sameSubset),
         })).stages;
     const teardown = (coll) => ({
         collection: coll,
@@ -1034,7 +1046,7 @@ const subMerge = (args, out, gid, extra, idPrefix, first) => {
         touchedAt: ['touchedAt', to(current)],
     };
     const updater = set()(addTSAndExtra);
-    const whenMatched = getWhenMatched(out.whenNotMatched);
+    const whenMatched = getWhenMatched(out.whenNotMatched, null);
     return link()
         .with($set_(set()(addExtraAndMerge)))
         .with($merge_({
@@ -1700,6 +1712,7 @@ const $replaceWith = (expr) => ({
 
 const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    const sameSubset = getSubsetMatchForExt(ext);
     return {
         teardown: c => c({
             collection: out,
@@ -1720,13 +1733,16 @@ const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: getWhenMatchedForMerge('insert', update),
+                whenMatched: getWhenMatchedForMerge('insert', update, sameSubset),
                 whenNotMatched: 'insert',
             })).stages;
         },
     };
 };
-const $simpleInsert = (out) => $insertX(out, root().expr(), id$1, {}, {});
+const $simpleInsert = (out, ext) => {
+    const extExpr = mapExact(ext, (v) => val(v));
+    return $insertX(out, root().expr(), id$1, ext, extExpr);
+};
 const $insertPart = (out, ext) => {
     const extExpr = mapExact(ext, (v) => val(v));
     return $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field(mergeExpr(translateOmit().forward(extExpr), {
@@ -2181,7 +2197,6 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
                     .with(input.delta)
                     .with(stages).stages,
             }), false, start);
-            stages.at(-1).$merge.into.coll;
             return next(step5({ ts: result.cursor.atClusterTime, aggResult, stream, nextRes, first }), 'remove handled deleted updated');
         };
         const step5 = (l) => async () => {
@@ -2523,6 +2538,7 @@ exports.floor = floor;
 exports.from = from;
 exports.fromEq = fromEq;
 exports.func = func;
+exports.getSubsetMatchForExt = getSubsetMatchForExt;
 exports.getWhenMatched = getWhenMatched;
 exports.getWhenMatchedForMerge = getWhenMatchedForMerge;
 exports.gt = gt;

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,38 @@
+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 getSubsetMatchForExt: <Out extends Model, P extends Model, E extends Record<keyof E, rawItem>>(ext: Exact<E, IdHKT>) => null | Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>>;
+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>, canWrite: Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>> | null) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
+export declare const getWhenMatched: <Out extends Model, P extends Model>(whenNotMatched: "discard" | "fail" | "insert", canWrite: Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>> | null) => 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, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => 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, GroupMergeOut, } 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';

package/lib/aggregate/mongo-stages.d.ts

@@ -0,0 +1,13 @@
+import type { Arr, O, Rec } from '../../types';
+import type { Accumulators, Expr, LookupArgs, Query, RawStages } from '../types';
+import type { Updater } from '../update/updater';
+export * from './raws';
+type s = string;
+export declare const $match_: <T extends O, C = unknown>(query?: Query<T, C>) => RawStages<O<T>, T, T, C>;
+export declare const $set_: <Q, T extends Q & O, V extends Q & O, C = unknown>(updater: Updater<T, T, V, C>) => RawStages<O<Q>, T, V, C, 1>;
+export declare const $replaceWith_: <T extends O, V extends O, C = unknown>(expr: Expr<V, T, C>) => RawStages<O, T, V, C, 1>;
+export declare const $unwind_: <T extends O, K extends s, U, Null extends null = never>(k: K, includeNull?: Null) => RawStages<O<T>, T & Rec<K, Arr<U>>, T & Rec<K, Null | U>>;
+export 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>;
+export declare const $documents_: <T extends O, C>(docs: Expr<Arr<T>, unknown, C>) => RawStages<unknown, null, T, C, 1>;
+export declare const $project_: <T extends O, K extends import("../..").StrKey<T>>(projection: import("../utils").ExactKeys<K>) => RawStages<T, T, T, unknown, 1>;
+export declare const $simpleLookup_: <T extends O, U extends O, R, K extends s, Ctx, C = unknown, S = string>(args: LookupArgs<T, U, R, K, Ctx, C, S>) => RawStages<O<T>, T, T & Rec<K, Arr<U>>, C, 1>;

package/lib/aggregate/out.d.ts

@@ -0,0 +1,37 @@
+import type { O, RWCollection, ReadonlyCollection, Replace, jsonItem } from '../../types';
+import type { ExprsExact } from '../expression/concat';
+import { type Field } from '../field';
+import type { RawStages } from '../types';
+export type MergeInto<T extends O, Out extends O, E = unknown> = {
+    whenNotMatched: 'insert';
+    into: RWCollection<T, Out> & E;
+} | {
+    whenNotMatched: 'discard' | 'fail';
+    into: ReadonlyCollection<Out> & E;
+};
+export type MergeArgs<T extends O, Out extends O, Ctx, In extends O> = {
+    on: Field<T, jsonItem> & Field<Out, jsonItem>;
+} & MergeInto<T, Out> & (({
+    stages?: never;
+} & ({
+    whenMatched: 'keepExisting' | 'fail';
+} | {
+    whenMatched: 'replace';
+    into: RWCollection<T, Out>;
+} | {
+    whenMatched: 'merge';
+    into: RWCollection<Replace<Out, T>, Out>;
+})) | {
+    stages: true;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In, {
+        new: T;
+    }>;
+} | {
+    stages: 'ctx';
+    vars: ExprsExact<Ctx, T>;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In, Ctx>;
+});
+export declare const $merge_: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>({ into, on, whenNotMatched, ...notMatched }: MergeArgs<T, Out, Ctx, In>) => RawStages<unknown, T, "out", unknown, number>;
+export declare const $merge2: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>(args: MergeArgs<T, Out, Ctx, In>) => RawStages<unknown, T, "out", unknown, number>;

package/lib/aggregate/prefix.d.ts

@@ -0,0 +1,33 @@
+import type { App, HKT, O2, O3, O, RawObj } from '../../types';
+import type { Delta, DeltaStages, FRawStages, RawStages, Stream, TStages } from '../types';
+import type { Equal } from '../utils/guard';
+type n = number;
+export declare const asStages: <Q, T extends Q, V extends Q, C = unknown, M extends n = number>(x: readonly RawObj[]) => RawStages<Q, T, V, C, M>;
+export declare const same: <T extends Dom, V extends Dom, F extends HKT<Dom, Q>, Dom = unknown, Q = unknown, C = unknown, M extends n = number>(_: Equal<Dom, T, V>) => RawStages<Q, App<F, T>, App<F, V>, C, M>;
+export declare const concatStages: <Q, T extends Q, V extends Q, W extends Q, C, M extends n = number>(part1: RawStages<Q, T, V, C, M>, part2: RawStages<Q, V, W, C, M>) => RawStages<Q, T, W, C, M>;
+export declare const concatFStages: <Q, T extends Q & O, V extends Q & O, W extends Q & O, C, M extends n = number>(part1: FRawStages<Q, T, V, C, M>, part2: FRawStages<Q, V, W, C, M>) => FRawStages<Q, T, W, C, M>;
+export declare const concatDelta: <Q extends O, T extends Q, V extends Q, W extends Q>(part1: DeltaStages<Q, T, V>, part2: DeltaStages<Q, V, W>) => DeltaStages<Q, T, W>;
+export type Concat<out Q, in T extends Q, out V extends Q, in out C, in out M extends n = n> = {
+    with: <Q2, W extends Q2>(extra: RawStages<Q | Q2, V, W, C, M>) => Concat<Q | Q2, T, W, C, M>;
+    stages: RawStages<Q, T, V, C, M>;
+};
+type FConcat<out Q, in T extends Q & O, out V extends Q & O, in out C, in out M extends n = n> = {
+    with: <Q2, W extends Q2 & O>(extra: FRawStages<Q | Q2, V, W, C, M>) => FConcat<Q | Q2, T, W, C, M>;
+    stages: FRawStages<Q, T, V, C, M>;
+};
+export type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
+    with: <Q2 extends O, V extends Q2>(map: (a: Stream<Q, T, F, G>) => Stream<Q | Q2, V, F, G>) => DeltaPipe<Q | Q2, V, F, G>;
+    then: <Q2 extends O, V extends Q2>(next: App<G, [Q2 | T, T, V]>) => DeltaPipe<Q | Q2, V, F, G>;
+    get: () => App<F, [Q, T]>;
+};
+export declare const pipe: <Q extends O, S extends Q, T extends Q, F extends HKT<O2>, G extends HKT<O3>>(stream: Stream<Q, S, F, G>, s: App<G, [Q, S, T]>, concat: <Q_1 extends O, T_1 extends Q_1, V extends Q_1, W extends Q_1>(part1: App<G, [Q_1, T_1, V]>, part2: App<G, [Q_1, V, W]>) => App<G, [Q_1, T_1, W]>, empty: <T_2 extends Q>() => App<G, [Q, T_2, T_2]>) => DeltaPipe<Q, T, F, G>;
+type Link = <T, C = unknown, M extends n = n>() => Concat<T, T, T, C, M>;
+type FLink = <T extends O, C = unknown, M extends n = n>() => FConcat<T, T, T, C, M>;
+export declare const link: Link;
+export declare const flink: FLink;
+export declare const emptyDelta: <T extends O>() => {
+    delta: RawStages<Delta<T>, Delta<T>, Delta<T>, unknown, number>;
+    raw: <F extends HKT<O>>() => RawStages<App<F, T>, App<F, T>, App<F, T>, unknown, number>;
+};
+export declare const concatTStages: <S, Q, B extends Q, T extends Q, V extends Q>({ coll, exec, input }: TStages<S, Q, B, T>, stages: RawStages<Q, T, V>) => TStages<S, Q, B, V>;
+export {};