@omegup/msync 0.0.54 → 0.0.56

package/index.d.ts

@@ -449,31 +449,6 @@ declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG ext
 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">;
 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" | keyof Omit<V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
 
-declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
-declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
-declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
-    expr: Expr<Arr<T>, D, C>;
-    as: K;
-    cond: Expr<unknown, D, C & RORec<K, T>>;
-    limit?: Expr<number, D, C>;
-}) => Expr<Arr<T>, D, C>;
-declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
-    expr: Expr<Arr<T>, D, C>;
-    sortBy: K;
-    order?: 1 | -1;
-}) => Expr<Arr<T>, D, C>;
-declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
-declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
-declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
-declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
-declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
-declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
-type NullToOBJ<N extends null> = N extends null ? O : N;
-declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(exprs_0: Expr<T1 | N, D, C>, exprs_1: Expr<T2, D, C>) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
-declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
-declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
-declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
-
 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>;
@@ -481,10 +456,9 @@ type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S exte
     as: AsLiteral<As>;
 };
 declare const $lookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
-declare const $outerLookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr, LNull extends null = never, RNull extends null = never>(p: Params<As, LQ, RQ, RE, S>, outer: {
-    left?: LNull;
-    right?: RNull;
-}) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ | NullToOBJ<RNull>, (LE | NullToOBJ<RNull>) & RORec<As, RE | LNull>>;
+declare const $outerLookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr, Null extends null = never>(p: Params<As, LQ, RQ, RE, S>, outer?: {
+    left?: Null;
+}) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE | Null>>;
 
 declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
 
@@ -576,6 +550,31 @@ declare function floor<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
 declare function ceil<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
 declare function ceil<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
 
+declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
+declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
+declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
+    expr: Expr<Arr<T>, D, C>;
+    as: K;
+    cond: Expr<unknown, D, C & RORec<K, T>>;
+    limit?: Expr<number, D, C>;
+}) => Expr<Arr<T>, D, C>;
+declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
+    expr: Expr<Arr<T>, D, C>;
+    sortBy: K;
+    order?: 1 | -1;
+}) => Expr<Arr<T>, D, C>;
+declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
+declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
+declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+type NullToOBJ<N extends null> = N extends null ? O : N;
+declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(exprs_0: Expr<T1 | N, D, C>, exprs_1: Expr<T2, D, C>) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
+declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
+declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
+declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
+
 declare const dayAndMonthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
 declare const now: <D, C>() => Expr<Date, D, C>;
 declare const monthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;

package/index.esm.js

@@ -468,7 +468,7 @@ const $replaceWith1 = (expr) => f => {
 const $unwind1 = (k, includeNull) => f => {
     const path = `$${f().of(k).str()}`;
     return asStages([
-        { $unwind: path },
+        { $unwind: includeNull === null ? { path, preserveNullAndEmptyArrays: true } : path },
     ]);
 };
 const $group1 = (id, args) => (f) => asStages([
@@ -501,7 +501,7 @@ const $simpleLookup1 = (args) => f => {
 const $match_ = (query) => $match1(query)(root);
 const $set_ = (updater) => $set1(updater)(root);
 const $replaceWith_ = (expr) => $replaceWith1(expr)(root);
-const $unwind_ = (k, includeNull) => $unwind1(k)(root);
+const $unwind_ = (k, includeNull) => $unwind1(k, includeNull)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
@@ -1086,9 +1086,8 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
     })).with($unwindDelta(k1, k2, k, includeNull)).stages;
 };
 
-const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNull) => (f) => {
     root().of('_id').expr();
-    root().of(k2).of('_id').expr();
     return link()
         .with($simpleLookup1({
         coll,
@@ -1100,7 +1099,7 @@ const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) =>
             .with(exec)
             .with($replaceWith_(root().of('before').expr())).stages,
     })(f))
-        .with($unwind1(k2)(f))
+        .with($unwind1(k2, includeNull)(f))
         .with(link().stages
         ).stages;
 };
@@ -1113,7 +1112,7 @@ const createIndex = async (collection, indexSpec, options) => {
             await collection.createIndex(indexSpec, options);
         }
         catch (e) {
-            if (e.code == 85) {
+            if ([85, 276].includes(e.code)) {
                 break;
             }
             if (e.code == 12587) {
@@ -1235,12 +1234,12 @@ const runCont = async (it, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft, outerRight) => {
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
     createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
     createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
     const rightJoinField = { field1: lField, field2: rField };
     const joinId = 'left';
-    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as));
+    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
     const idB = { _id: 'b' };
@@ -1249,7 +1248,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         stages: consume => consume(concatTStages(resultingSnapshot, asBefore(stagesUntilNextLookup.raw))),
         out: (finalInput) => {
             const leftJoinField = { field1: rField, field2: lField };
-            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId, outerRight);
+            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId);
             const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, outerLeft);
             const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({ a: root().of('right').expr(), b: root().of('_id').expr() }, dictId))), stagesUntilNextLookup.delta);
             const lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
@@ -1264,7 +1263,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         },
     };
 };
-const $lookup1 = (p, outer) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outer?.left, outer?.right)));
+const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
 const $lookup = (p) => (l) => $lookup1({
     right: p.from,
     as: p.as,
@@ -1278,7 +1277,7 @@ const $outerLookup = (p, outer) => (l) => $lookup1({
     lField: p.localField,
     rField: p.foreignField,
     left: l(emptyDelta()),
-}, outer);
+}, outer?.left);
 
 const filterUndefined = (applyOperator) => {
     return (op, args) => applyOperator(op, args.filter(defined));
@@ -1392,8 +1391,9 @@ const aggregate = (streamName, input, snapshot = true, start = Date.now()) => in
     };
     log('exec', streamName, req);
     return coll.s.db.command(req).then(result => {
-        log('execed', streamName, req, result, 'took', Date.now() - start);
-        return result;
+        const r = result;
+        log('execed', streamName, (replace) => replace(JSON.stringify(req).replaceAll('$$CLUSTER_TIME', JSON.stringify(r.cursor.atClusterTime))), result, 'took', Date.now() - start);
+        return r;
     }, err => {
         log('err', req, err);
         throw new Error(err);
@@ -1444,23 +1444,21 @@ const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startA
         },
     });
     pipeline.push({
-        $replaceWith: {
-            _id: "$_id",
-            ts: {
-                $cond: {
-                    if: {
-                        $or: [
-                            { $ne: ['$fullDocument', '$fullDocumentBeforeChange'] },
-                            { $and: changeKeys.map(k => ({ $eq: [k, null] })) },
-                        ],
-                    },
-                    then: null,
-                    else: '$clusterTime',
-                },
-            },
+        $match: {
+            $or: [
+                { $expr: { $ne: ['$fullDocument', '$fullDocumentBeforeChange'] } },
+                Object.fromEntries(changeKeys.map(k => [k, null])),
+            ],
+        },
+    });
+    pipeline.push({
+        $project: {
+            _id: 1,
         },
     });
-    const stream = db.collection(collection.collectionName).watch(pipeline, {
+    const stream = db
+        .collection(collection.collectionName)
+        .watch(pipeline, {
         fullDocument: 'required',
         fullDocumentBeforeChange: 'required',
         startAtOperationTime: startAt,
@@ -1483,7 +1481,7 @@ const actions = {
     ],
 };
 const streamNames = {};
-const executes$1 = (view, input, streamName) => {
+const executes$1 = (view, input, streamName, skip = false) => {
     const hash = crypto$1
         .createHash('md5')
         .update(new Error().stack + '')
@@ -1536,6 +1534,8 @@ const executes$1 = (view, input, streamName) => {
             input: input.delta,
             finalInputFirst: finalInput.raw(true),
             finalInput: finalInput.raw(false),
+            match: view.match?.raw(root()).get(),
+            project: projection,
             teardown: finalInput.teardown((x) => ({
                 collection: x.collection.collectionName,
                 method: x.method,
@@ -1571,13 +1571,17 @@ const executes$1 = (view, input, streamName) => {
                 await Promise.all([snapshotCollection.drop(), action]);
                 log('teardown done', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
             };
-            if (exists && !same)
+            if (exists && !same) {
                 await handleTeardown(exists);
-            return next(step3(same), 'clone into new collection');
+            }
+            return nextData([])(async () => {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                return step3(same)();
+            }, 'clone into new collection');
         };
         const step3 = (lastTS) => async () => {
             const hardQuery = $and(lastTS
-                ? root().of('touchedAt').has($gteTs(lastTS.ts))
+                ? root().of('touchedAt').has($gtTs(lastTS.ts))
                 : root().of('deletedAt').has($eq(null)), lastTS ? null : match && $expr(match), hardMatch);
             const notDeleted = eq($ifNull(root().of('deletedAt').expr(), nil))(nil);
             const query = match ? and(notDeleted, match) : notDeleted;
@@ -1655,13 +1659,11 @@ const executes$1 = (view, input, streamName) => {
                 log('restarting', err);
                 return { ts: null };
             })
-                .then(doc => doc
-                ? doc.ts
-                    ? next(step7({ ...l, ts: doc.ts }), 'nothing changed')
-                    : next(step2, 'restart')
-                : step8(l)), 'wait for change');
+                .then(doc => (doc ? next(step3({ _id: streamName, ts: l.ts }), 'restart') : step8(l))), 'wait for change');
         };
-        return stop;
+        return skip
+            ? withStop(() => SynchronousPromise.resolve(next(step3(null), 'clone into new collection')))
+            : stop;
     };
     const hasBefore = root().of('before').has($ne(null));
     return {
@@ -1684,7 +1686,9 @@ const executes = (view, input, streamName) => {
         streamNames[streamName] = hash;
     else if (streamNames[streamName] != hash)
         throw new Error('streamName already used');
-    const { collection, projection, hardMatch, match } = view;
+    const { collection, projection, hardMatch: pre, match } = view;
+    const removeNotYetSynchronizedFields = Object.values(mapExactToObject(projection, (_, k) => k.startsWith('_') ? root().of(k).has($exists(true)) : null));
+    const hardMatch = $and(pre, ...removeNotYetSynchronizedFields);
     const job = {};
     const db = collection.s.db, coll = collection.collectionName;
     db.command({
@@ -1715,6 +1719,8 @@ const executes = (view, input, streamName) => {
             input: input,
             finalInputFirst: finalInput.raw(true),
             finalInput: finalInput.raw(false),
+            match: view.match?.raw(root()).get(),
+            project: projection,
             teardown: finalInput.teardown((x) => ({
                 collection: x.collection.collectionName,
                 method: x.method,
@@ -1744,7 +1750,14 @@ const executes = (view, input, streamName) => {
             };
             if (exists && !same)
                 await handleTeardown(exists);
-            return next(step4(same), 'clone into new collection');
+            return {
+                cont: withStop(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    return step4(same)();
+                }),
+                data: [],
+                info: { debug: 'clone into new collection', job: undefined },
+            };
         };
         const makeStream = (startAt) => makeWatchStream(db, view, startAt, streamName);
         const step4 = (lastTS) => async () => {
@@ -1770,11 +1783,7 @@ const executes = (view, input, streamName) => {
                 info: { job: undefined, debug: 'wait for change' },
                 cont: withStop(() => l.stream
                     .tryNext()
-                    .then(doc => doc
-                    ? doc.ts
-                        ? next(step7({ ...l, ts: doc.ts }), 'nothing changed')
-                        : next(step1, 'restart')
-                    : step8(l))),
+                    .then(doc => (doc ? next(step4({ _id: streamName, ts: l.ts }), 'restart') : step8(l)))),
             };
         };
         return stop;

package/index.js

@@ -470,7 +470,7 @@ const $replaceWith1 = (expr) => f => {
 const $unwind1 = (k, includeNull) => f => {
     const path = `$${f().of(k).str()}`;
     return asStages([
-        { $unwind: path },
+        { $unwind: includeNull === null ? { path, preserveNullAndEmptyArrays: true } : path },
     ]);
 };
 const $group1 = (id, args) => (f) => asStages([
@@ -503,7 +503,7 @@ const $simpleLookup1 = (args) => f => {
 const $match_ = (query) => $match1(query)(root);
 const $set_ = (updater) => $set1(updater)(root);
 const $replaceWith_ = (expr) => $replaceWith1(expr)(root);
-const $unwind_ = (k, includeNull) => $unwind1(k)(root);
+const $unwind_ = (k, includeNull) => $unwind1(k, includeNull)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
@@ -1088,9 +1088,8 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
     })).with($unwindDelta(k1, k2, k, includeNull)).stages;
 };
 
-const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNull) => (f) => {
     root().of('_id').expr();
-    root().of(k2).of('_id').expr();
     return link()
         .with($simpleLookup1({
         coll,
@@ -1102,7 +1101,7 @@ const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) =>
             .with(exec)
             .with($replaceWith_(root().of('before').expr())).stages,
     })(f))
-        .with($unwind1(k2)(f))
+        .with($unwind1(k2, includeNull)(f))
         .with(link().stages
         ).stages;
 };
@@ -1115,7 +1114,7 @@ const createIndex = async (collection, indexSpec, options) => {
             await collection.createIndex(indexSpec, options);
         }
         catch (e) {
-            if (e.code == 85) {
+            if ([85, 276].includes(e.code)) {
                 break;
             }
             if (e.code == 12587) {
@@ -1237,12 +1236,12 @@ const runCont = async (it, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft, outerRight) => {
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
     createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
     createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
     const rightJoinField = { field1: lField, field2: rField };
     const joinId = 'left';
-    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as));
+    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
     const idB = { _id: 'b' };
@@ -1251,7 +1250,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         stages: consume => consume(concatTStages(resultingSnapshot, asBefore(stagesUntilNextLookup.raw))),
         out: (finalInput) => {
             const leftJoinField = { field1: rField, field2: lField };
-            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId, outerRight);
+            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId);
             const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, outerLeft);
             const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({ a: root().of('right').expr(), b: root().of('_id').expr() }, dictId))), stagesUntilNextLookup.delta);
             const lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
@@ -1266,7 +1265,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         },
     };
 };
-const $lookup1 = (p, outer) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outer?.left, outer?.right)));
+const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
 const $lookup = (p) => (l) => $lookup1({
     right: p.from,
     as: p.as,
@@ -1280,7 +1279,7 @@ const $outerLookup = (p, outer) => (l) => $lookup1({
     lField: p.localField,
     rField: p.foreignField,
     left: l(emptyDelta()),
-}, outer);
+}, outer?.left);
 
 const filterUndefined = (applyOperator) => {
     return (op, args) => applyOperator(op, args.filter(defined));
@@ -1394,8 +1393,9 @@ const aggregate = (streamName, input, snapshot = true, start = Date.now()) => in
     };
     log('exec', streamName, req);
     return coll.s.db.command(req).then(result => {
-        log('execed', streamName, req, result, 'took', Date.now() - start);
-        return result;
+        const r = result;
+        log('execed', streamName, (replace) => replace(JSON.stringify(req).replaceAll('$$CLUSTER_TIME', JSON.stringify(r.cursor.atClusterTime))), result, 'took', Date.now() - start);
+        return r;
     }, err => {
         log('err', req, err);
         throw new Error(err);
@@ -1446,23 +1446,21 @@ const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startA
         },
     });
     pipeline.push({
-        $replaceWith: {
-            _id: "$_id",
-            ts: {
-                $cond: {
-                    if: {
-                        $or: [
-                            { $ne: ['$fullDocument', '$fullDocumentBeforeChange'] },
-                            { $and: changeKeys.map(k => ({ $eq: [k, null] })) },
-                        ],
-                    },
-                    then: null,
-                    else: '$clusterTime',
-                },
-            },
+        $match: {
+            $or: [
+                { $expr: { $ne: ['$fullDocument', '$fullDocumentBeforeChange'] } },
+                Object.fromEntries(changeKeys.map(k => [k, null])),
+            ],
+        },
+    });
+    pipeline.push({
+        $project: {
+            _id: 1,
         },
     });
-    const stream = db.collection(collection.collectionName).watch(pipeline, {
+    const stream = db
+        .collection(collection.collectionName)
+        .watch(pipeline, {
         fullDocument: 'required',
         fullDocumentBeforeChange: 'required',
         startAtOperationTime: startAt,
@@ -1485,7 +1483,7 @@ const actions = {
     ],
 };
 const streamNames = {};
-const executes$1 = (view, input, streamName) => {
+const executes$1 = (view, input, streamName, skip = false) => {
     const hash = crypto$1
         .createHash('md5')
         .update(new Error().stack + '')
@@ -1538,6 +1536,8 @@ const executes$1 = (view, input, streamName) => {
             input: input.delta,
             finalInputFirst: finalInput.raw(true),
             finalInput: finalInput.raw(false),
+            match: view.match?.raw(root()).get(),
+            project: projection,
             teardown: finalInput.teardown((x) => ({
                 collection: x.collection.collectionName,
                 method: x.method,
@@ -1573,13 +1573,17 @@ const executes$1 = (view, input, streamName) => {
                 await Promise.all([snapshotCollection.drop(), action]);
                 log('teardown done', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
             };
-            if (exists && !same)
+            if (exists && !same) {
                 await handleTeardown(exists);
-            return next(step3(same), 'clone into new collection');
+            }
+            return nextData([])(async () => {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                return step3(same)();
+            }, 'clone into new collection');
         };
         const step3 = (lastTS) => async () => {
             const hardQuery = $and(lastTS
-                ? root().of('touchedAt').has($gteTs(lastTS.ts))
+                ? root().of('touchedAt').has($gtTs(lastTS.ts))
                 : root().of('deletedAt').has($eq(null)), lastTS ? null : match && $expr(match), hardMatch);
             const notDeleted = eq($ifNull(root().of('deletedAt').expr(), nil))(nil);
             const query = match ? and(notDeleted, match) : notDeleted;
@@ -1657,13 +1661,11 @@ const executes$1 = (view, input, streamName) => {
                 log('restarting', err);
                 return { ts: null };
             })
-                .then(doc => doc
-                ? doc.ts
-                    ? next(step7({ ...l, ts: doc.ts }), 'nothing changed')
-                    : next(step2, 'restart')
-                : step8(l)), 'wait for change');
+                .then(doc => (doc ? next(step3({ _id: streamName, ts: l.ts }), 'restart') : step8(l))), 'wait for change');
         };
-        return stop;
+        return skip
+            ? withStop(() => synchronousPromise.SynchronousPromise.resolve(next(step3(null), 'clone into new collection')))
+            : stop;
     };
     const hasBefore = root().of('before').has($ne(null));
     return {
@@ -1686,7 +1688,9 @@ const executes = (view, input, streamName) => {
         streamNames[streamName] = hash;
     else if (streamNames[streamName] != hash)
         throw new Error('streamName already used');
-    const { collection, projection, hardMatch, match } = view;
+    const { collection, projection, hardMatch: pre, match } = view;
+    const removeNotYetSynchronizedFields = Object.values(mapExactToObject(projection, (_, k) => k.startsWith('_') ? root().of(k).has($exists(true)) : null));
+    const hardMatch = $and(pre, ...removeNotYetSynchronizedFields);
     const job = {};
     const db = collection.s.db, coll = collection.collectionName;
     db.command({
@@ -1717,6 +1721,8 @@ const executes = (view, input, streamName) => {
             input: input,
             finalInputFirst: finalInput.raw(true),
             finalInput: finalInput.raw(false),
+            match: view.match?.raw(root()).get(),
+            project: projection,
             teardown: finalInput.teardown((x) => ({
                 collection: x.collection.collectionName,
                 method: x.method,
@@ -1746,7 +1752,14 @@ const executes = (view, input, streamName) => {
             };
             if (exists && !same)
                 await handleTeardown(exists);
-            return next(step4(same), 'clone into new collection');
+            return {
+                cont: withStop(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    return step4(same)();
+                }),
+                data: [],
+                info: { debug: 'clone into new collection', job: undefined },
+            };
         };
         const makeStream = (startAt) => makeWatchStream(db, view, startAt, streamName);
         const step4 = (lastTS) => async () => {
@@ -1772,11 +1785,7 @@ const executes = (view, input, streamName) => {
                 info: { job: undefined, debug: 'wait for change' },
                 cont: withStop(() => l.stream
                     .tryNext()
-                    .then(doc => doc
-                    ? doc.ts
-                        ? next(step7({ ...l, ts: doc.ts }), 'nothing changed')
-                        : next(step1, 'restart')
-                    : step8(l))),
+                    .then(doc => (doc ? next(step4({ _id: streamName, ts: l.ts }), 'restart') : step8(l)))),
             };
         };
         return stop;

package/package.json

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