@omegup/msync 0.0.14 → 0.0.16

package/index.d.ts

@@ -1,4 +1,4 @@
-import { Timestamp, BSON, Db, Collection, IndexSpecification, CreateIndexesOptions, MongoClient as MongoClient$1, OptionalUnlessRequiredId } from 'mongodb';
+import { Timestamp, Filter, UpdateFilter, BSON, Db, Collection, IndexSpecification, CreateIndexesOptions, MongoClient as MongoClient$1, OptionalUnlessRequiredId } from 'mongodb';
 export { Collection, Timestamp } from 'mongodb';
 import * as bson from 'bson';
 
@@ -15,7 +15,7 @@ type Frame<T, Info> = {
 type IteratorResult<out T, out Info> = {
     next: NextFrame<T, Info>;
     stop: Iterator<T, Info>;
-    clear: () => Promise<void>;
+    clear: () => Promise<unknown>;
 };
 type Iterator<out T, out Info> = () => IteratorResult<T, Info>;
 
@@ -83,10 +83,19 @@ type TStages<in out S, out Q, in out B extends Q, out R extends Q, M extends num
     exec: RawStages<Q, B, R, unknown, M>;
 };
 type Stages<out Q, out R extends Q, out SDom> = <E>(consume: <S extends SDom, B extends Q>(value: TStages<S, Q, B, R>) => E) => E;
-type StreamRunner<out V> = <Result>(input: RawStages<unknown, V, Result>) => Runner<readonly Result[], HasJob>;
-type SimpleStreamExecutionResult<out Q, out V extends Q> = {
-    readonly out: StreamRunner<V>;
+type Actions<W> = {
+    updateMany: [Filter<W>, UpdateFilter<W> | BSON.Document[]];
 };
+type TeardownRecord<W, M extends keyof Actions<W>> = {
+    collection: WriteonlyCollection<W>;
+    method: M;
+    params: Actions<W>[M];
+};
+type StreamRunnerParam<in V, out Result> = {
+    raw: (first: boolean) => RawStages<unknown, V, Result>;
+    teardown: <R>(consume: <W, M extends keyof Actions<W>>(x: TeardownRecord<W, M>) => R) => R;
+};
+type StreamRunner<out V> = <Result>(input: StreamRunnerParam<V, Result>) => Runner<readonly Result[], HasJob>;
 type SnapshotStreamExecutionResult<out Q, out V extends Q> = {
     readonly out: StreamRunner<Delta<V>>;
     readonly stages: Stages<Before<Q>, Before<V>, UBefore<Q>>;
@@ -428,9 +437,9 @@ type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof
 
 type Denied<GID = never> = keyof (TS & ID) | GID;
 type GI<GG> = Exclude<GG, keyof TS>;
-declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, V, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => RawStages<unknown, Delta<T>, "out">;
-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>>) => RawStages<unknown, 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) => RawStages<unknown, Delta<T>, "out">;
+declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, V, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
+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">;
 
 type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
     localField: Field<LQ, S>;
@@ -466,16 +475,16 @@ type s = string;
 declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;
 
 type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
-type Allowed$2<K extends string> = Exclude<K, keyof (TS & ID)>;
-type Patch<V, KK extends StrKey<V>> = ((OPick<V, Allowed$2<KK>> & ID) | (Rec<Allowed$2<KK>, N> & ID)) & TS;
-declare const $simpleMerge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$2<KK>>) => RawStages<unknown, OutInputE<OPick<V, Allowed$2<KK>> & ID, unknown>, "out">;
-declare const $merge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$2<KK>>) => RawStages<unknown, Delta<OPick<V, Allowed$2<KK>> & ID>, "out">;
+type Allowed$1<K extends string> = Exclude<K, keyof (TS & ID)>;
+type Patch<V, KK extends StrKey<V>> = ((OPick<V, Allowed$1<KK>> & ID) | (Rec<Allowed$1<KK>, N> & ID)) & TS;
+declare const $simpleMerge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$1<KK>>) => StreamRunnerParam<OutInputE<OPick<V, Allowed$1<KK>> & ID, unknown>, "out">;
+declare const $merge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$1<KK>>) => StreamRunnerParam<Delta<OPick<V, Allowed$1<KK>> & ID>, "out">;
 
 type ND = {
     readonly deletedAt?: null;
 };
 type Merge<T extends ID> = (T & ND & TS) | Del;
-declare const $upsert: <T extends doc>(out: RWCollection<Merge<T>>) => RawStages<unknown, Delta<T>, "out">;
+declare const $upsert: <T extends doc>(out: RWCollection<Merge<T>>) => StreamRunnerParam<Delta<T>, "out">;
 
 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>;
@@ -483,25 +492,15 @@ type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> =
     get: () => App<F, [Q, T]>;
 };
 
-type Allowed$1<K> = Exclude<K, 'deletedAt' | '_id'>;
-type AllowedPick$1<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed$1<K>>;
+type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
+type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
 interface SnapshotStreamHKT extends HKT<O2> {
     readonly out: SnapshotStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
 }
 interface DeltaHKT extends HKT<O3> {
     readonly out: DeltaStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2]>;
 }
-declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>>, streamName: string) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT, DeltaHKT>;
-
-type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
-type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
-interface StreamRunnerHKT extends HKT<O2> {
-    readonly out: SimpleStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
-}
-interface StagesHKT extends HKT<O3> {
-    readonly out: RORec<'lin', RawStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2], unknown, 1>>;
-}
-declare const from: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
+declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, SnapshotStreamHKT, DeltaHKT>;
 
 declare const max: <D, C>(...expr: Expr<number, D, C>[]) => Expr<number, D, C>;
 declare const lt: <D, C>(expr_0: Expr<number, D, C>, expr_1: Expr<number, D, C>) => Expr<boolean, D, C>;
@@ -642,4 +641,4 @@ 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, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleMerge, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleMerge, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };

package/index.esm.js

@@ -549,7 +549,7 @@ const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
     },
 ]);
 
-const subMerge = (args, out, gid, extra, idPrefix) => {
+const subMerge = (args, out, gid, extra, idPrefix, first) => {
     const doubleReplace = (x) => x;
     const mergeAggregates = $set_(set()(mapExact0(args, (v, k) => to(v.merge(root().of(k).expr(), ctx()('new').of(k).expr())))));
     const gidPath = root().of(gid).expr();
@@ -573,12 +573,16 @@ const subMerge = (args, out, gid, extra, idPrefix) => {
         .with($set_(set()(addExtraAndMerge)))
         .with($merge_({
         ...out,
-        vars: { new: ['new', root().expr()] },
-        stages: 'ctx',
         on: root().of(gid),
-        whenMatched: link()
-            .with(mergeAggregates)
-            .with(doubleReplace($set_(updater))).stages,
+        ...(first
+            ? { whenMatched: 'merge' }
+            : {
+                vars: { new: ['new', root().expr()] },
+                stages: 'ctx',
+                whenMatched: link()
+                    .with(mergeAggregates)
+                    .with(doubleReplace($set_(updater))).stages,
+            }),
     })).stages);
 };
 
@@ -586,11 +590,26 @@ const addGrp = (gid) => (expr) => {
     const omit = omitPick();
     return omit.backward(mergeExpr(omit.forward(expr), map1(gid, root().of('_id').expr())));
 };
-const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => {
-    return link()
+const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => ({
+    raw: (first) => link()
         .with(subGroup(id, args, addGrp(gid)))
-        .with(subMerge(args, out, gid, extra, idPrefix)).stages;
-};
+        .with(subMerge(args, out, gid, extra, idPrefix, first)).stages,
+    teardown: c => c({
+        collection: out.into,
+        method: 'updateMany',
+        params: [
+            {},
+            [
+                {
+                    $unset: Object.keys({
+                        ...mapExactToObject(extra, () => 1),
+                        ...mapExactToObject(args, () => 1),
+                    }),
+                },
+            ],
+        ],
+    }),
+});
 const $groupId = (id, args, out, extra) => $groupMerge(id, args, { into: out, whenNotMatched: 'fail' }, '_id', extra);
 const $group = (id, args, out, extra, idPrefix = '') => $groupMerge(id, args, { into: out, whenNotMatched: 'insert' }, '_grp', extra, idPrefix);
 
@@ -936,8 +955,12 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
             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);
             const rRunnerInput = concatStages(joinL_Delta, mergeForeignIntoDoc);
-            const lRunner = left.out(concatStages(lRunnerInput, finalInput));
-            const rRunner = right.out(concatStages(rRunnerInput, finalInput));
+            const getRunner = (f, stages, final) => f.out({
+                raw: first => concatStages(stages, final.raw(first)),
+                teardown: final.teardown,
+            });
+            const lRunner = getRunner(left, lRunnerInput, finalInput);
+            const rRunner = getRunner(right, rRunnerInput, finalInput);
             return () => merge({ lsource: lRunner(), rsource: rRunner() });
         },
     };
@@ -1010,25 +1033,39 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeId = () => (out, keys, id) => {
-    const omRORec = omitRORec();
-    const patch = mapExactToObject(keys, (_, k) => [k, root().of('after').of(k).expr()]);
-    const replacer = ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
-        _id: ['_id', id],
-        touchedAt: ['touchedAt', current],
-    }))), field(omitPick().backward(spread(patch, {
-        _id: ['_id', root().of('after').of('_id').expr()],
-        touchedAt: ['touchedAt', current],
-    }))));
-    return link()
-        .with($replaceWith_(replacer))
-        .with($merge_({
-        into: out,
-        on: root().of('_id'),
-        whenNotMatched: 'fail',
-        whenMatched: 'merge',
-    })).stages;
-};
+const $mergeId = () => (out, keys, id) => ({
+    raw: (first) => {
+        const omRORec = omitRORec();
+        const patch = mapExactToObject(keys, (_, k) => [k, root().of('after').of(k).expr()]);
+        const replacer = ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
+            _id: ['_id', id],
+            touchedAt: ['touchedAt', current],
+        }))), field(omitPick().backward(spread(patch, {
+            _id: ['_id', root().of('after').of('_id').expr()],
+            touchedAt: ['touchedAt', current],
+        }))));
+        return link()
+            .with($replaceWith_(replacer))
+            .with($merge_({
+            into: out,
+            on: root().of('_id'),
+            whenNotMatched: 'fail',
+            whenMatched: 'merge',
+        })).stages;
+    },
+    teardown: c => c({
+        collection: out,
+        method: 'updateMany',
+        params: [
+            {},
+            [
+                {
+                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
+                },
+            ],
+        ],
+    }),
+});
 const $simpleMerge = () => (out, keys) => $mergeId()(out, keys, root().of('_id').expr());
 const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull$1(root()
     .of('before')
@@ -1036,21 +1073,28 @@ const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull$1(root()
     .expr()));
 const assertNotNull$1 = (expr) => expr;
 
-const $upsert = (out) => {
-    const replacer = ite(eq(root().of('after').expr())(nil), field({
-        deletedAt: ['deletedAt', current],
-        _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
-        touchedAt: ['touchedAt', current],
-    }), mergeObjects(assertNotNull(root().of('after').expr()), field({ deletedAt: ['deletedAt', nil], touchedAt: ['touchedAt', current] })));
-    return link()
-        .with($replaceWith_(replacer))
-        .with($merge_({
-        into: out,
-        on: root().of('_id'),
-        whenMatched: 'merge',
-        whenNotMatched: 'insert',
-    })).stages;
-};
+const $upsert = (out) => ({
+    teardown: c => c({
+        collection: out,
+        method: 'updateMany',
+        params: [{}, [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }]],
+    }),
+    raw: () => {
+        const replacer = ite(eq(root().of('after').expr())(nil), field({
+            deletedAt: ['deletedAt', current],
+            _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
+            touchedAt: ['touchedAt', current],
+        }), mergeObjects(assertNotNull(root().of('after').expr()), field({ deletedAt: ['deletedAt', nil], touchedAt: ['touchedAt', current] })));
+        return link()
+            .with($replaceWith_(replacer))
+            .with($merge_({
+            into: out,
+            on: root().of('_id'),
+            whenMatched: 'merge',
+            whenNotMatched: 'insert',
+        })).stages;
+    },
+});
 const assertNotNull = (expr) => expr;
 
 const T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
@@ -1135,8 +1179,11 @@ const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startA
     return { tryNext, close: () => stream.close() };
 };
 
+const actions = {
+    updateMany: (c, args) => c.updateMany(...args),
+};
 const streamNames = {};
-const executes$1 = (view, input, streamName) => {
+const executes = (view, input, streamName) => {
     const hash = crypto$1
         .createHash('md5')
         .update(new Error().stack + '')
@@ -1173,9 +1220,7 @@ const executes$1 = (view, input, streamName) => {
         _id: ['_id', 1],
     }));
     const run = (finalInput) => {
-        const clear = async () => {
-            await snapshotCollection.drop();
-        };
+        const clear = async () => Promise.all([snapshotCollection.drop(), last.deleteOne({ _id: streamName })]);
         const withStop = (next, tr) => {
             return addTeardown(() => ({ stop, next: next(), clear }), tr);
         };
@@ -1184,13 +1229,40 @@ const executes$1 = (view, input, streamName) => {
             data: [],
             info: { job, debug },
         });
+        const data = {
+            input: input.delta,
+            finalInputFirst: finalInput.raw(true),
+            finalInput: finalInput.raw(false),
+            teardown: finalInput.teardown((x) => ({
+                collection: x.collection.collectionName,
+                method: x.method,
+                params: x.params,
+            })),
+        };
         const step0 = () => Promise.resolve(next(step1, 'empty new collection'));
         const stop = withStop(step0);
         const step1 = async () => {
             await snapshotCollection.updateMany({ updated: true }, { $set: { updated: false, after: null } });
             return next(step2, 'get last update');
         };
-        const step2 = () => last.findOne({ _id: streamName }).then(ts => next(step3(ts), 'clone into new collection'));
+        const step2 = () => Promise.all([
+            last.findOne({ _id: streamName, data }),
+            last.findOne({ _id: streamName }),
+        ]).then(ts => next(step2_5(ts), 'handle teardown'));
+        const step2_5 = ([same, exists]) => async () => {
+            const handleTeardown = async (last) => {
+                const { collection: c, method: m, params: p } = last.data.teardown;
+                const { collection, method, params } = {
+                    collection: db.collection(c),
+                    method: m,
+                    params: p,
+                };
+                await actions[method](collection, params);
+            };
+            if (exists && !same)
+                await handleTeardown(exists);
+            return next(step3(same), 'clone into new collection');
+        };
         const step3 = (lastTS) => async () => {
             const hardQuery = $and(lastTS && root().of('touchedAt').has($gteTs(lastTS.ts)), hardMatch);
             const notDeleted = eq($ifNull(root().of('deletedAt').expr(), nil))(nil);
@@ -1212,10 +1284,10 @@ const executes$1 = (view, input, streamName) => {
             })).stages;
             const r = await aggregate(c => c({ coll: collection, input: cloneIntoNew }));
             await snapshotCollection.deleteMany({ updated: true, after: null, before: null });
-            return next(step4(r), 'run the aggregation');
+            return next(step4({ result: r, ts: lastTS?.ts }), 'run the aggregation');
         };
         const makeStream = (startAt) => makeWatchStream(db, view, startAt);
-        const step4 = (result) => async () => {
+        const step4 = ({ result, ts }) => async () => {
             const start = Date.now();
             await snapshotCollection.updateMany({ before: null }, { $set: { before: null } });
             const aggResult = await aggregate(c => c({
@@ -1224,7 +1296,7 @@ const executes$1 = (view, input, streamName) => {
                     .with($match_(root().of('updated').has($eq(true))))
                     .with($match_($expr(ne(root().of('after').expr())(root().of('before').expr()))))
                     .with(input.delta)
-                    .with(finalInput).stages,
+                    .with(finalInput.raw(ts === undefined)).stages,
             }), false, start);
             const stream = makeStream(result.cursor.atClusterTime);
             return next(step5({ result, aggResult, stream }), 'remove handled deleted updated', () => stream.close());
@@ -1250,7 +1322,12 @@ const executes$1 = (view, input, streamName) => {
             return next(step7(l), 'update __last');
         };
         const step7 = (l) => async () => {
-            await last.updateOne({ _id: streamName }, { $set: { ts: l.result.cursor.atClusterTime } }, { upsert: true });
+            await last.updateOne({ _id: streamName }, {
+                $set: {
+                    ts: l.result.cursor.atClusterTime,
+                    data,
+                },
+            }, { upsert: true });
             return step8(l);
         };
         const step8 = (l) => {
@@ -1272,80 +1349,7 @@ const executes$1 = (view, input, streamName) => {
         out: run,
     };
 };
-const staging = (view, streamName) => pipe(input => executes$1(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
-
-const executes = (view, input, streamName) => {
-    const hash = crypto$1
-        .createHash('md5')
-        .update(new Error().stack + '')
-        .digest('base64url');
-    if (!streamNames[streamName])
-        streamNames[streamName] = hash;
-    else if (streamNames[streamName] != hash)
-        throw new Error('streamName already used');
-    const { collection, projection, hardMatch, match } = view;
-    const job = {};
-    const db = collection.s.db, coll = collection.collectionName;
-    db.command({
-        collMod: coll,
-        changeStreamPreAndPostImages: { enabled: true },
-    });
-    createIndex(collection, { touchedAt: 1 }, {
-        partialFilterExpression: { deletedAt: { $eq: null } },
-        name: 'touchedAt_' + new UUID().toString('base64'),
-    });
-    const last = db.collection('__last');
-    const projectInput = $project_(spread(projection, {
-        deletedAt: ['deletedAt', 1],
-        _id: ['_id', 1],
-    }));
-    const notDeleted = root().of('deletedAt').has($eq(null));
-    const run = (finalInput) => {
-        const clear = async () => { };
-        const withStop = (next, tr) => {
-            return addTeardown(() => ({ stop, next: next(), clear }), tr);
-        };
-        const next = (next, debug, tr) => ({
-            cont: withStop(next, tr),
-            data: [],
-            info: { job, debug },
-        });
-        const step0 = () => Promise.resolve(next(step1, 'get last update'));
-        const stop = withStop(step0);
-        const step1 = () => last.findOne({ _id: streamName }).then(ts => next(step4(ts), 'clone into new collection'));
-        const makeStream = (startAt) => makeWatchStream(db, view, startAt);
-        const step4 = (lastTS) => async () => {
-            const hardQuery = $and(lastTS && root().of('touchedAt').has($gteTs(lastTS.ts)), hardMatch, notDeleted, match && $expr(match));
-            const aggResult = await aggregate(c => c({
-                coll: collection,
-                input: link()
-                    .with($match_(hardQuery))
-                    .with(projectInput)
-                    .with(input)
-                    .with(finalInput).stages,
-            }));
-            const stream = makeStream(aggResult.cursor.atClusterTime);
-            return next(step7({ aggResult, result: aggResult, stream }), 'update __last', () => stream.close());
-        };
-        const step7 = (l) => async () => {
-            await last.updateOne({ _id: streamName }, { $set: { ts: l.result.cursor.atClusterTime } }, { upsert: true });
-            return step8(l);
-        };
-        const step8 = (l) => {
-            return {
-                data: l.aggResult.cursor.firstBatch,
-                info: { job: undefined, debug: 'wait for change' },
-                cont: withStop(() => l.stream.tryNext().then(doc => (doc ? next(step1, 'restart') : step8(l)))),
-            };
-        };
-        return stop;
-    };
-    return {
-        out: run,
-    };
-};
-const emptyLin = () => ({ lin: link().stages });
-const from = (view, streamName) => pipe(input => executes(view, input.lin, streamName), { lin: link().stages }, ({ lin: a }, { lin: b }) => ({ lin: concatStages(a, b) }), emptyLin);
+const staging = (view, streamName) => pipe(input => executes(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
 
 const dayAndMonthPart = (date) => asExpr({
     raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%m-%d' } }),
@@ -1625,4 +1629,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleMerge, $sum, $unwind, $unwindDelta, $upsert, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleMerge, $sum, $unwind, $unwindDelta, $upsert, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };

package/index.js

@@ -551,7 +551,7 @@ const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
     },
 ]);
 
-const subMerge = (args, out, gid, extra, idPrefix) => {
+const subMerge = (args, out, gid, extra, idPrefix, first) => {
     const doubleReplace = (x) => x;
     const mergeAggregates = $set_(set()(mapExact0(args, (v, k) => to(v.merge(root().of(k).expr(), ctx()('new').of(k).expr())))));
     const gidPath = root().of(gid).expr();
@@ -575,12 +575,16 @@ const subMerge = (args, out, gid, extra, idPrefix) => {
         .with($set_(set()(addExtraAndMerge)))
         .with($merge_({
         ...out,
-        vars: { new: ['new', root().expr()] },
-        stages: 'ctx',
         on: root().of(gid),
-        whenMatched: link()
-            .with(mergeAggregates)
-            .with(doubleReplace($set_(updater))).stages,
+        ...(first
+            ? { whenMatched: 'merge' }
+            : {
+                vars: { new: ['new', root().expr()] },
+                stages: 'ctx',
+                whenMatched: link()
+                    .with(mergeAggregates)
+                    .with(doubleReplace($set_(updater))).stages,
+            }),
     })).stages);
 };
 
@@ -588,11 +592,26 @@ const addGrp = (gid) => (expr) => {
     const omit = omitPick();
     return omit.backward(mergeExpr(omit.forward(expr), map1(gid, root().of('_id').expr())));
 };
-const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => {
-    return link()
+const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => ({
+    raw: (first) => link()
         .with(subGroup(id, args, addGrp(gid)))
-        .with(subMerge(args, out, gid, extra, idPrefix)).stages;
-};
+        .with(subMerge(args, out, gid, extra, idPrefix, first)).stages,
+    teardown: c => c({
+        collection: out.into,
+        method: 'updateMany',
+        params: [
+            {},
+            [
+                {
+                    $unset: Object.keys({
+                        ...mapExactToObject(extra, () => 1),
+                        ...mapExactToObject(args, () => 1),
+                    }),
+                },
+            ],
+        ],
+    }),
+});
 const $groupId = (id, args, out, extra) => $groupMerge(id, args, { into: out, whenNotMatched: 'fail' }, '_id', extra);
 const $group = (id, args, out, extra, idPrefix = '') => $groupMerge(id, args, { into: out, whenNotMatched: 'insert' }, '_grp', extra, idPrefix);
 
@@ -938,8 +957,12 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
             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);
             const rRunnerInput = concatStages(joinL_Delta, mergeForeignIntoDoc);
-            const lRunner = left.out(concatStages(lRunnerInput, finalInput));
-            const rRunner = right.out(concatStages(rRunnerInput, finalInput));
+            const getRunner = (f, stages, final) => f.out({
+                raw: first => concatStages(stages, final.raw(first)),
+                teardown: final.teardown,
+            });
+            const lRunner = getRunner(left, lRunnerInput, finalInput);
+            const rRunner = getRunner(right, rRunnerInput, finalInput);
             return () => merge({ lsource: lRunner(), rsource: rRunner() });
         },
     };
@@ -1012,25 +1035,39 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeId = () => (out, keys, id) => {
-    const omRORec = omitRORec();
-    const patch = mapExactToObject(keys, (_, k) => [k, root().of('after').of(k).expr()]);
-    const replacer = ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
-        _id: ['_id', id],
-        touchedAt: ['touchedAt', current],
-    }))), field(omitPick().backward(spread(patch, {
-        _id: ['_id', root().of('after').of('_id').expr()],
-        touchedAt: ['touchedAt', current],
-    }))));
-    return link()
-        .with($replaceWith_(replacer))
-        .with($merge_({
-        into: out,
-        on: root().of('_id'),
-        whenNotMatched: 'fail',
-        whenMatched: 'merge',
-    })).stages;
-};
+const $mergeId = () => (out, keys, id) => ({
+    raw: (first) => {
+        const omRORec = omitRORec();
+        const patch = mapExactToObject(keys, (_, k) => [k, root().of('after').of(k).expr()]);
+        const replacer = ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
+            _id: ['_id', id],
+            touchedAt: ['touchedAt', current],
+        }))), field(omitPick().backward(spread(patch, {
+            _id: ['_id', root().of('after').of('_id').expr()],
+            touchedAt: ['touchedAt', current],
+        }))));
+        return link()
+            .with($replaceWith_(replacer))
+            .with($merge_({
+            into: out,
+            on: root().of('_id'),
+            whenNotMatched: 'fail',
+            whenMatched: 'merge',
+        })).stages;
+    },
+    teardown: c => c({
+        collection: out,
+        method: 'updateMany',
+        params: [
+            {},
+            [
+                {
+                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
+                },
+            ],
+        ],
+    }),
+});
 const $simpleMerge = () => (out, keys) => $mergeId()(out, keys, root().of('_id').expr());
 const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull$1(root()
     .of('before')
@@ -1038,21 +1075,28 @@ const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull$1(root()
     .expr()));
 const assertNotNull$1 = (expr) => expr;
 
-const $upsert = (out) => {
-    const replacer = ite(eq(root().of('after').expr())(nil), field({
-        deletedAt: ['deletedAt', current],
-        _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
-        touchedAt: ['touchedAt', current],
-    }), mergeObjects(assertNotNull(root().of('after').expr()), field({ deletedAt: ['deletedAt', nil], touchedAt: ['touchedAt', current] })));
-    return link()
-        .with($replaceWith_(replacer))
-        .with($merge_({
-        into: out,
-        on: root().of('_id'),
-        whenMatched: 'merge',
-        whenNotMatched: 'insert',
-    })).stages;
-};
+const $upsert = (out) => ({
+    teardown: c => c({
+        collection: out,
+        method: 'updateMany',
+        params: [{}, [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }]],
+    }),
+    raw: () => {
+        const replacer = ite(eq(root().of('after').expr())(nil), field({
+            deletedAt: ['deletedAt', current],
+            _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
+            touchedAt: ['touchedAt', current],
+        }), mergeObjects(assertNotNull(root().of('after').expr()), field({ deletedAt: ['deletedAt', nil], touchedAt: ['touchedAt', current] })));
+        return link()
+            .with($replaceWith_(replacer))
+            .with($merge_({
+            into: out,
+            on: root().of('_id'),
+            whenMatched: 'merge',
+            whenNotMatched: 'insert',
+        })).stages;
+    },
+});
 const assertNotNull = (expr) => expr;
 
 const T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
@@ -1137,8 +1181,11 @@ const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startA
     return { tryNext, close: () => stream.close() };
 };
 
+const actions = {
+    updateMany: (c, args) => c.updateMany(...args),
+};
 const streamNames = {};
-const executes$1 = (view, input, streamName) => {
+const executes = (view, input, streamName) => {
     const hash = crypto$1
         .createHash('md5')
         .update(new Error().stack + '')
@@ -1175,9 +1222,7 @@ const executes$1 = (view, input, streamName) => {
         _id: ['_id', 1],
     }));
     const run = (finalInput) => {
-        const clear = async () => {
-            await snapshotCollection.drop();
-        };
+        const clear = async () => Promise.all([snapshotCollection.drop(), last.deleteOne({ _id: streamName })]);
         const withStop = (next, tr) => {
             return addTeardown(() => ({ stop, next: next(), clear }), tr);
         };
@@ -1186,13 +1231,40 @@ const executes$1 = (view, input, streamName) => {
             data: [],
             info: { job, debug },
         });
+        const data = {
+            input: input.delta,
+            finalInputFirst: finalInput.raw(true),
+            finalInput: finalInput.raw(false),
+            teardown: finalInput.teardown((x) => ({
+                collection: x.collection.collectionName,
+                method: x.method,
+                params: x.params,
+            })),
+        };
         const step0 = () => Promise.resolve(next(step1, 'empty new collection'));
         const stop = withStop(step0);
         const step1 = async () => {
             await snapshotCollection.updateMany({ updated: true }, { $set: { updated: false, after: null } });
             return next(step2, 'get last update');
         };
-        const step2 = () => last.findOne({ _id: streamName }).then(ts => next(step3(ts), 'clone into new collection'));
+        const step2 = () => Promise.all([
+            last.findOne({ _id: streamName, data }),
+            last.findOne({ _id: streamName }),
+        ]).then(ts => next(step2_5(ts), 'handle teardown'));
+        const step2_5 = ([same, exists]) => async () => {
+            const handleTeardown = async (last) => {
+                const { collection: c, method: m, params: p } = last.data.teardown;
+                const { collection, method, params } = {
+                    collection: db.collection(c),
+                    method: m,
+                    params: p,
+                };
+                await actions[method](collection, params);
+            };
+            if (exists && !same)
+                await handleTeardown(exists);
+            return next(step3(same), 'clone into new collection');
+        };
         const step3 = (lastTS) => async () => {
             const hardQuery = $and(lastTS && root().of('touchedAt').has($gteTs(lastTS.ts)), hardMatch);
             const notDeleted = eq($ifNull(root().of('deletedAt').expr(), nil))(nil);
@@ -1214,10 +1286,10 @@ const executes$1 = (view, input, streamName) => {
             })).stages;
             const r = await aggregate(c => c({ coll: collection, input: cloneIntoNew }));
             await snapshotCollection.deleteMany({ updated: true, after: null, before: null });
-            return next(step4(r), 'run the aggregation');
+            return next(step4({ result: r, ts: lastTS?.ts }), 'run the aggregation');
         };
         const makeStream = (startAt) => makeWatchStream(db, view, startAt);
-        const step4 = (result) => async () => {
+        const step4 = ({ result, ts }) => async () => {
             const start = Date.now();
             await snapshotCollection.updateMany({ before: null }, { $set: { before: null } });
             const aggResult = await aggregate(c => c({
@@ -1226,7 +1298,7 @@ const executes$1 = (view, input, streamName) => {
                     .with($match_(root().of('updated').has($eq(true))))
                     .with($match_($expr(ne(root().of('after').expr())(root().of('before').expr()))))
                     .with(input.delta)
-                    .with(finalInput).stages,
+                    .with(finalInput.raw(ts === undefined)).stages,
             }), false, start);
             const stream = makeStream(result.cursor.atClusterTime);
             return next(step5({ result, aggResult, stream }), 'remove handled deleted updated', () => stream.close());
@@ -1252,7 +1324,12 @@ const executes$1 = (view, input, streamName) => {
             return next(step7(l), 'update __last');
         };
         const step7 = (l) => async () => {
-            await last.updateOne({ _id: streamName }, { $set: { ts: l.result.cursor.atClusterTime } }, { upsert: true });
+            await last.updateOne({ _id: streamName }, {
+                $set: {
+                    ts: l.result.cursor.atClusterTime,
+                    data,
+                },
+            }, { upsert: true });
             return step8(l);
         };
         const step8 = (l) => {
@@ -1274,80 +1351,7 @@ const executes$1 = (view, input, streamName) => {
         out: run,
     };
 };
-const staging = (view, streamName) => pipe(input => executes$1(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
-
-const executes = (view, input, streamName) => {
-    const hash = crypto$1
-        .createHash('md5')
-        .update(new Error().stack + '')
-        .digest('base64url');
-    if (!streamNames[streamName])
-        streamNames[streamName] = hash;
-    else if (streamNames[streamName] != hash)
-        throw new Error('streamName already used');
-    const { collection, projection, hardMatch, match } = view;
-    const job = {};
-    const db = collection.s.db, coll = collection.collectionName;
-    db.command({
-        collMod: coll,
-        changeStreamPreAndPostImages: { enabled: true },
-    });
-    createIndex(collection, { touchedAt: 1 }, {
-        partialFilterExpression: { deletedAt: { $eq: null } },
-        name: 'touchedAt_' + new mongodb.UUID().toString('base64'),
-    });
-    const last = db.collection('__last');
-    const projectInput = $project_(spread(projection, {
-        deletedAt: ['deletedAt', 1],
-        _id: ['_id', 1],
-    }));
-    const notDeleted = root().of('deletedAt').has($eq(null));
-    const run = (finalInput) => {
-        const clear = async () => { };
-        const withStop = (next, tr) => {
-            return addTeardown(() => ({ stop, next: next(), clear }), tr);
-        };
-        const next = (next, debug, tr) => ({
-            cont: withStop(next, tr),
-            data: [],
-            info: { job, debug },
-        });
-        const step0 = () => Promise.resolve(next(step1, 'get last update'));
-        const stop = withStop(step0);
-        const step1 = () => last.findOne({ _id: streamName }).then(ts => next(step4(ts), 'clone into new collection'));
-        const makeStream = (startAt) => makeWatchStream(db, view, startAt);
-        const step4 = (lastTS) => async () => {
-            const hardQuery = $and(lastTS && root().of('touchedAt').has($gteTs(lastTS.ts)), hardMatch, notDeleted, match && $expr(match));
-            const aggResult = await aggregate(c => c({
-                coll: collection,
-                input: link()
-                    .with($match_(hardQuery))
-                    .with(projectInput)
-                    .with(input)
-                    .with(finalInput).stages,
-            }));
-            const stream = makeStream(aggResult.cursor.atClusterTime);
-            return next(step7({ aggResult, result: aggResult, stream }), 'update __last', () => stream.close());
-        };
-        const step7 = (l) => async () => {
-            await last.updateOne({ _id: streamName }, { $set: { ts: l.result.cursor.atClusterTime } }, { upsert: true });
-            return step8(l);
-        };
-        const step8 = (l) => {
-            return {
-                data: l.aggResult.cursor.firstBatch,
-                info: { job: undefined, debug: 'wait for change' },
-                cont: withStop(() => l.stream.tryNext().then(doc => (doc ? next(step1, 'restart') : step8(l)))),
-            };
-        };
-        return stop;
-    };
-    return {
-        out: run,
-    };
-};
-const emptyLin = () => ({ lin: link().stages });
-const from = (view, streamName) => pipe(input => executes(view, input.lin, streamName), { lin: link().stages }, ({ lin: a }, { lin: b }) => ({ lin: concatStages(a, b) }), emptyLin);
+const staging = (view, streamName) => pipe(input => executes(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
 
 const dayAndMonthPart = (date) => asExpr({
     raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%m-%d' } }),
@@ -1698,7 +1702,6 @@ exports.filterDefined = filterDefined;
 exports.first = first$1;
 exports.firstSure = firstSure;
 exports.floor = floor;
-exports.from = from;
 exports.func = func;
 exports.gt = gt;
 exports.gte = gte;

package/package.json

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