@omegup/msync 0.0.1

package/index.js

@@ -0,0 +1,1684 @@
+'use strict';
+
+var mongodb = require('mongodb');
+var crypto = require('crypto');
+var promises = require('fs/promises');
+
+const asExprRaw = (raw) => ({ get: () => raw });
+const asExpr = (r) => r;
+const asBoolExpr = (r) => r;
+
+const max = (...expr) => asExpr({
+    raw: f => asExprRaw({ $max: expr.map(e => e.raw(f).get()) }),
+});
+const lt = (...expr) => asExpr({
+    raw: f => asExprRaw({ $lt: expr.map(e => e.raw(f).get()) }),
+});
+const gt = (...expr) => asExpr({
+    raw: f => asExprRaw({ $gt: expr.map(e => e.raw(f).get()) }),
+});
+const lte = (...expr) => asExpr({
+    raw: f => asExprRaw({ $lte: expr.map(e => e.raw(f).get()) }),
+});
+const gte = (...expr) => asExpr({
+    raw: f => asExprRaw({ $gte: expr.map(e => e.raw(f).get()) }),
+});
+function subtract(...expr) {
+    return asExpr({
+        raw: f => asExprRaw({ $subtract: expr.map(e => e.raw(f).get()) }),
+    });
+}
+function add(...expr) {
+    return asExpr({
+        raw: f => asExprRaw({ $add: expr.map(e => e.raw(f).get()) }),
+    });
+}
+function divide(...expr) {
+    return asExpr({
+        raw: f => asExprRaw({ $divide: expr.map(e => e.raw(f).get()) }),
+    });
+}
+function multiply(...expr) {
+    return asExpr({
+        raw: f => asExprRaw({ $multiply: expr.map(e => e.raw(f).get()) }),
+    });
+}
+function floor(expr) {
+    return asExpr({
+        raw: f => asExprRaw({ $floor: expr.raw(f).get() }),
+    });
+}
+function ceil(expr) {
+    return asExpr({
+        raw: f => asExprRaw({ $ceil: expr.raw(f).get() }),
+    });
+}
+
+const id$1 = (x) => x;
+const defined = (x) => x != null;
+const map1 = (k, to) => {
+    const k2 = k;
+    return { [k]: [k2, to] };
+};
+
+const map = (x, f) => Object.fromEntries(Object.entries(x).map(([k, v]) => [k, f(v, k)]));
+const mapExactToObject0 = (x, f) => {
+    const filter = (x) => x.filter((x) => x[0] === x[1][0]);
+    const matched = filter(Object.entries(x));
+    return Object.fromEntries(matched.map(([k, v]) => [k, f(v[1], k)]));
+};
+const mapExactToObject1 = (x, f) => mapExactToObject0(x, f);
+const mapExact0 = (x, f) => mapExactToObject0(x, (v, k) => [k, f(v, k)]);
+const mapExact1 = (x, f) => mapExactToObject1(x, (v, k) => [k, f(v, k)]);
+const mapExactToObject = (x, f) => mapExactToObject0(x, f);
+const mapExact = (x, f) => mapExactToObject(x, (v, k) => [k, f(v, k)]);
+const spread = (a, b) => ({ ...a, ...mapExact(b, id$1) });
+
+const val = (val) => asExpr({
+    raw: () => asExprRaw((val && typeof val === 'object') || (typeof val === 'string' && val[0] === '$')
+        ? { $literal: val }
+        : val),
+});
+const current = asExpr({
+    raw: () => asExprRaw('$$CLUSTER_TIME'),
+});
+const $let = (vars, inExpr) => asExpr({
+    raw: f => asExprRaw({
+        $let: {
+            vars: mapExactToObject(vars, v => v.raw(f).get()),
+            in: inExpr.raw(f).get(),
+        },
+    }),
+});
+const nil = val(null);
+const $getField = (expr, field) => asExpr({
+    raw: f => asExprRaw({
+        $getField: {
+            field: field,
+            input: expr.raw(f).get(),
+        },
+    }),
+});
+const func = (f, ...args) => asExpr({
+    raw: field => asExprRaw({
+        $function: {
+            body: f.toString(),
+            args: args.map(x => x.raw(field).get()),
+            lang: 'js',
+        },
+    }),
+});
+const rand = function () {
+    const s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array(17)
+        .fill(0)
+        .map(() => s[Math.floor(Math.random() * 62)])
+        .join('');
+};
+const $rand = func(rand);
+
+const ite = ((cond, then, orelse) => asExpr({
+    raw: (f) => asExprRaw({
+        $cond: {
+            if: cond.raw(f).get(),
+            then: then.raw(f).get(),
+            else: orelse.raw(f).get(),
+        },
+    }),
+}));
+const and = (...expr) => asExpr({
+    raw: f => asExprRaw({ $and: expr.map(e => e.raw(f).get()) }),
+});
+const eq = (a) => (b) => asExpr({
+    raw: f => asExprRaw({ $eq: [a.raw(f).get(), b.raw(f).get()] }),
+});
+const sub = (a, f) => asExpr({
+    raw: (g) => asExprRaw(a.raw(g.with(f)).get()),
+});
+const eqTyped = (a, b) => asBoolExpr({
+    raw: (f) => asExprRaw({ $eq: [a.raw(f).get(), b.raw(f).get()] }),
+});
+const ne = (a) => (b) => asExpr({
+    raw: f => asExprRaw({ $ne: [a.raw(f).get(), b.raw(f).get()] }),
+});
+const notNull = (a) => ne($ifNull(a, nil))(nil);
+const $ifNull = (...expr) => asExpr({
+    raw: f => asExprRaw({ $ifNull: expr.map(e => e.raw(f).get()) }),
+});
+const exprMapVal = (expr, map, or) => asExpr({
+    raw: f => asExprRaw({
+        $switch: {
+            branches: Object.entries(map).map(([k, v]) => ({
+                case: { $eq: [expr.raw(f).get(), { $literal: k }] },
+                then: v.raw(f).get(),
+            })),
+            ...(or && { default: or.raw(f).get() }),
+        },
+    }),
+});
+const mapVal = (expr, map, or) => exprMapVal(expr, Object.fromEntries(Object.entries(map).map(([k, v]) => [k, val(v)])), val(or));
+const setField = ({ field, input, value, }) => asExpr({
+    raw: f => asExprRaw({
+        $setField: {
+            field: field.raw(f).get(),
+            input: input.raw(f).get(),
+            value: value.raw(f).get(),
+        },
+    }),
+});
+
+class Field {
+    field;
+    raw;
+    concat;
+    has(p) {
+        return { raw: f => ({ [f.with(this).str()]: p.raw }) };
+    }
+    constructor(field, raw, concat) {
+        this.field = field;
+        this.raw = raw;
+        this.concat = concat;
+    }
+    static root = () => {
+        const concat = (f1, f2) => new Field([f1.field, f2.field].filter(id$1).join('.'), f1.raw, f1.concat);
+        return new Field('', s => (s ? `$${s}` : '$$ROOT'), concat);
+    };
+    static ctx = () => (k) => {
+        const concat = (_, f2) => new Field(f2.field, f2.raw, f2.concat);
+        return new Field(k, s => `$$${s}`, concat);
+    };
+    of(k) {
+        return new Field([this.field, k].filter(id$1).join('.'), this.raw, this.concat);
+    }
+    with(k) {
+        return k.concat(this, k);
+    }
+    str() {
+        return this.field;
+    }
+    exprRaw() {
+        return asExprRaw(this.raw(this.field));
+    }
+    expr() {
+        return asExpr({
+            raw: (f) => f.with(this).exprRaw(),
+        });
+    }
+}
+const { root, ctx } = Field;
+
+const asAccumulator = (x) => x;
+const $sum_ = (expr) => ({ raw: f => asAccumulator({ $sum: expr.raw(f).get() }) });
+const $sum = (expr) => ({
+    group: $sum_(ite(root().of('old').expr(), subtract(val(0), $ifNull(sub(expr, root().of('v')), val(0))), sub(expr, root().of('v')))),
+    merge: (x, y) => add($ifNull(x, val(0)), y),
+});
+const $accumulator_ = (init, accumulateArgs, accumulate, merge) => {
+    return {
+        raw: f => asAccumulator({
+            $accumulator: {
+                init: init.toString(),
+                initArgs: [],
+                accumulate: accumulate.toString(),
+                accumulateArgs: accumulateArgs.map(e => e.raw(f).get()),
+                merge: merge.toString(),
+                lang: 'js',
+            },
+        }),
+    };
+};
+const $accumulator = (init, accumulateArgs, accumulate, merge) => ({
+    group: $accumulator_(init, accumulateArgs, accumulate, merge),
+    merge: (a, b) => func(merge, a, b),
+});
+const $countDict = (expr) => $accumulator(function () {
+    return {};
+}, [sub(expr, root().of('v')), root().of('old').expr()], function (a, k, old) {
+    let y = (a[k] || 0) + (old ? -1 : 1);
+    return y ? (a[k] = y) : delete a[k], a;
+}, function (a, b) {
+    return Object.keys(b).reduce((a, k) => {
+        let y = (a[k] || 0) + b[k];
+        return y ? (a[k] = y) : delete a[k], a;
+    }, a || {});
+});
+const $pushDict = (key, value) => $accumulator(function () {
+    return {};
+}, [
+    sub(key, root().of('v')),
+    sub(value, root().of('v')),
+    root().of('old').expr(),
+], function (ra, k, v, old) {
+    let a = { ...ra };
+    const equal = (a, b) => {
+        if ([a, b].some(a => !a || typeof a != 'object'))
+            return a === b;
+        const keys = Object.keys(a);
+        return keys.length === Object.keys(b).length && keys.every(k => equal(a[k], b[k]));
+    };
+    const delta = (a[k] ||= { 0: [], 1: [] }), addR = delta[old ? 1 : 0], rmR = delta[old ? 0 : 1], idx = rmR.findIndex(x => equal(x, v));
+    if (idx !== -1)
+        rmR.splice(idx, 1);
+    else
+        addR.push(v);
+    return a;
+}, function (acc, b) {
+    return Object.keys(b).reduce((a, k) => {
+        return Object.entries({ ...b[k] }).reduce((a, [p, v]) => v.reduce((a, v) => {
+            const equal = (a, b) => {
+                if ([a, b].some(a => !a || typeof a != 'object'))
+                    return a === b;
+                const keys = Object.keys(a);
+                return keys.length === Object.keys(b).length && keys.every(k => equal(a[k], b[k]));
+            };
+            const delta = (a[k] ||= { 0: [], 1: [] }), addR = delta[p], rmR = delta[+p ? 0 : 1], idx = rmR.findIndex(x => equal(x, v));
+            if (idx !== -1)
+                rmR.splice(idx, 1);
+            else
+                addR.push(v);
+            return a;
+        }, a), a);
+    }, acc || {});
+});
+const $keys = (expr) => func(function (obj) {
+    return Object.keys(obj);
+}, expr);
+const $entries = (expr) => func(function (obj) {
+    return Object.entries({ ...obj }).flatMap(([k, v]) => v[0].map(v => ({ k, v })));
+}, expr);
+
+const concat$2 = (...expr) => asExpr({
+    raw: f => asExprRaw({ $concat: expr.map(e => e.raw(f).get()) }),
+});
+const fieldM = (expr, m) => asExpr({
+    raw: (f) => asExprRaw(Object.fromEntries(Object.entries(m).map(([dom, ref]) => [
+        dom,
+        expr[ref].raw(f).get(),
+    ]))),
+});
+const mergeExact = (...[exprsExact1, exprsExact2]) => spread(exprsExact1, exprsExact2);
+const mergeExpr = (...exprs) => mergeExact(...exprs);
+const fieldF = () => (exprs) => Object.keys(exprs).length
+    ? asExpr({
+        raw: f => asExprRaw(mapExactToObject(exprs, e => e.raw(f).get())),
+    })
+    : val({});
+const field = fieldF();
+
+const id = (x) => x;
+const assertEqual = () => ({
+    forward: id,
+    backward: id,
+    forward1: id,
+    backward1: id,
+});
+const omitRORec = () => assertEqual();
+const omitPick = () => assertEqual();
+
+const asStages = (x) => x;
+const concatStages = (part1, part2) => asStages([...part1, ...part2]);
+const concatDelta = (part1, part2) => ({
+    delta: concatStages(part1.delta, part2.delta),
+    raw: f => concatStages(part1.raw(f), part2.raw(f)),
+});
+const pipe = (stream, s, concat, empty) => {
+    const acc = {
+        with: (map) => pipe(map(i => stream(concat(s, i))), empty(), concat, empty),
+        then: (next) => pipe(stream, concat(s, next), concat, empty),
+        get: () => stream(s),
+    };
+    return acc;
+};
+const concat$1 = (stages) => ({
+    with: extra => concat$1(concatStages(stages, extra)),
+    stages,
+});
+const link = () => ({
+    with: extra => concat$1(extra),
+    stages: asStages([]),
+});
+const emptyDelta = () => ({
+    delta: link().stages,
+    raw: () => link().stages,
+});
+const concatTStages = ({ coll, exec, input }, stages) => ({ coll, input, exec: concatStages(exec, stages) });
+
+const size = (expr) => asExpr({
+    raw: f => asExprRaw({ $size: expr.raw(f).get() }),
+});
+const filterDefined = (expr) => filter({
+    expr,
+    as: 'x',
+    cond: ctx()('x').expr(),
+});
+const filter = ({ as, cond, expr, limit, }) => asExpr({
+    raw: f => asExprRaw({
+        $filter: {
+            input: expr.raw(f).get(),
+            as,
+            cond: cond.raw(f).get(),
+            limit: limit?.raw(f).get(),
+        },
+    }),
+});
+const sortArray = ({ sortBy, expr, order, }) => asExpr({
+    raw: f => asExprRaw({ $sortArray: { input: expr.raw(f).get(), sortBy: { [sortBy]: order ?? -1 } } }),
+});
+const isArray = (expr) => asBoolExpr({
+    raw: f => asExprRaw({ $isArray: expr.raw(f).get() }),
+});
+const array = (...exprs) => asExpr({
+    raw: f => asExprRaw(exprs.map(x => x.raw(f).get())),
+});
+const concat = (...exprs) => asExpr({
+    raw: f => asExprRaw({ $concatArrays: exprs.map(x => x.raw(f).get()) }),
+});
+const first$1 = (expr) => asExpr({
+    raw: f => asExprRaw({ $first: expr.raw(f).get() }),
+});
+const firstSure = first$1;
+const last = (expr) => asExpr({
+    raw: f => asExprRaw({ $last: expr.raw(f).get() }),
+});
+const mergeObjects = (...exprs) => asExpr({
+    raw: f => asExprRaw({ $mergeObjects: exprs.map(x => x.raw(f).get()) }),
+});
+const inArray = (...exprs) => asExpr({
+    raw: f => asExprRaw({ $in: exprs.map(x => x.raw(f).get()) }),
+});
+const reduce = (input, initialValue, inExpr) => asExpr({
+    raw: f => asExprRaw({
+        $reduce: {
+            input: input.raw(f).get(),
+            initialValue: initialValue.raw(f).get(),
+            in: inExpr.raw(f).get(),
+        },
+    }),
+});
+const indexOfArray = (array, item) => asExpr({
+    raw: f => asExprRaw({
+        $indexOfArray: [array.raw(f).get(), item.raw(f).get()],
+    }),
+});
+const slice = (array, start, end) => asExpr({
+    raw: f => asExprRaw({
+        $slice: [array.raw(f).get(), start.raw(f).get(), end.raw(f).get()],
+    }),
+});
+const except = (a, b) => {
+    const value = ctx()('value');
+    const out = value.of('out').expr();
+    const except = value.of('except').expr();
+    const curr = ctx()('this').expr();
+    const indexInExcept = ctx()('indexInExcept').expr();
+    return $let({
+        res: [
+            'res',
+            reduce(a, field({ out: ['out', array()], except: ['except', b] }), $let({
+                indexInExcept: ['indexInExcept', indexOfArray(except, curr)],
+            }, ite(gte(indexInExcept, val(0)), field({
+                out: ['out', out],
+                except: [
+                    'except',
+                    concat(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except))),
+                ],
+            }), field({
+                out: ['out', concat(out, array(curr))],
+                except: ['except', except],
+            })))),
+        ],
+    }, ctx()('res').of('out').expr());
+};
+
+const $match1 = (query) => f => asStages(query ? [{ $match: query.raw(f()) }] : []);
+const $set1 = (updater) => f => asStages([
+    {
+        $set: Object.fromEntries(updater.raw(f()).map(([k, v]) => [
+            f()
+                .of(k.slice(1))
+                .str(),
+            v,
+        ])),
+    },
+]);
+const $project1 = (projection) => asStages([
+    {
+        $project: mapExactToObject(projection, () => 1),
+    },
+]);
+const $replaceWith1 = (expr) => f => {
+    const parts = f().str().split('.').filter(id$1);
+    return asStages([
+        { $replaceWith: parts.reduce((v, k) => ({ [k]: v }), expr.raw(f()).get()) },
+    ]);
+};
+const $unwind1 = (k) => f => asStages([{ $unwind: `$${f().of(k).str()}` }]);
+const $group1 = (id, args) => (f) => asStages([
+    {
+        $group: {
+            _id: id.raw(f()).get(),
+            ...mapExactToObject(args, v => v.raw(f())),
+        },
+    },
+]);
+const rawVars = (vars, f) => mapExactToObject(vars, v => v.raw(f).get());
+const $simpleLookup1 = (args) => f => {
+    const { coll, k, vars, fields, ...etc } = args;
+    return asStages([
+        {
+            $lookup: {
+                ...(coll && { from: coll.collectionName }),
+                ...(fields && {
+                    localField: f().with(fields.local).str(),
+                    foreignField: root().with(fields.foreign).str(),
+                }),
+                as: f().of(k).str(),
+                let: rawVars(vars, f()),
+                ...etc,
+            },
+        },
+    ]);
+};
+
+const $match_ = (query) => $match1(query)(root);
+const $set_ = (updater) => $set1(updater)(root);
+const $replaceWith_ = (expr) => $replaceWith1(expr)(root);
+const $unwind_ = (k) => $unwind1(k)(root);
+const $group_ = () => (id, args) => $group1(id, args)(root);
+const $project_ = $project1;
+const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
+
+const subGroup = (id, args, addGrp) => {
+    const part = filterDefined(array(ite(eqTyped(root().of('after').expr(), nil), nil, field({
+        v: ['v', root().of('after').expr()],
+        old: ['old', val(false)],
+    })), ite(eqTyped(root().of('before').expr(), nil), nil, field({
+        v: ['v', root().of('before').expr()],
+        old: ['old', val(true)],
+    }))));
+    const replaceWith = (expr) => $replaceWith_(expr);
+    return link()
+        .with($replaceWith_(field({
+        part: ['part', part],
+    })))
+        .with($unwind_('part'))
+        .with($replaceWith_(root().of('part').expr()))
+        .with($group_()(sub(id, root().of('v')), mapExact(args, v => v.group)))
+        .with(replaceWith(field(addGrp(mapExact(args, (_, k) => $getField(root().expr(), k)))))).stages;
+};
+
+const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
+const set = () => (fields) => ({
+    raw: f => {
+        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+    },
+});
+const weaken = (updater) => ({ raw: f => updater.raw(f) });
+const to = (expr) => ({
+    raw: f => [['', expr.raw(f).get()]],
+});
+
+const dbcoll = (x) => ({
+    db: x.dbName,
+    coll: x.collectionName,
+});
+
+const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
+    {
+        $merge: {
+            into: dbcoll(into),
+            on: on.str(),
+            ...(whenNotMatched && { whenNotMatched }),
+            ...(notMatched.stages && {
+                whenMatched: notMatched.whenMatched,
+                ...(notMatched.stages === 'ctx' && { let: rawVars(notMatched.vars, root()) }),
+            }),
+        },
+    },
+]);
+
+const subMerge = (args, out, gid, extra, idPrefix) => {
+    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();
+    const mapId = (k, v) => map1(k, v);
+    const F1 = {
+        _id: ['_id', to(idPrefix ? concat$2(val(idPrefix), $rand) : $rand)],
+        touchedAt: ['touchedAt', to(current)],
+    };
+    const F2 = mapId(gid, to(gidPath));
+    const addExtraAndMerge = {
+        ...mapExact0(extra, to),
+        ...F1,
+        ...F2,
+    };
+    const addTSAndExtra = {
+        ...mapExact0(extra, to),
+        touchedAt: ['touchedAt', to(current)],
+    };
+    const updater = set()(addTSAndExtra);
+    return (link()
+        .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,
+    })).stages);
+};
+
+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()
+        .with(subGroup(id, args, addGrp(gid)))
+        .with(subMerge(args, out, gid, extra, idPrefix)).stages;
+};
+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);
+
+const $expr = (expr) => ({
+    raw: f => ({ $expr: expr.raw(f).get() }),
+});
+
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+    root().of('_id').expr();
+    root().of(k2).of('_id').expr();
+    return link()
+        .with($simpleLookup1({
+        coll,
+        k: k2,
+        vars: map1('local', root().with(field1).expr()),
+        pipeline: link()
+            .with(input)
+            .with($match_($expr(eq(ctx()('local').expr())(root().of('before').with(field2).expr()))))
+            .with(exec)
+            .with($replaceWith_(root().of('before').expr())).stages,
+    })(f))
+        .with($unwind1(k2)(f))
+        .with(link().stages
+        ).stages;
+};
+
+const deltaExpr = (expr) => (field) => {
+    return ite(eqTyped(root().of(field).expr(), nil), nil, expr(field));
+};
+const $setEach1 = (updater, dict) => {
+    return $set1(set()(mapExact1(dict, updater)));
+};
+const $setEach = (updater, dict) => $setEach1(updater, dict)(root);
+const $replaceWithEach = (expr) => {
+    const t = deltaExpr(expr);
+    return $setEach(k => to(t(k)), {
+        after: ['after', 'after'],
+        before: ['before', 'before'],
+    });
+};
+
+const $replaceWithDelta = (expr) => $replaceWithEach((field) => sub(expr, root().of(field)));
+const $setDelta = (updater) => {
+    const dict = {
+        after1: ['after1', 'after'],
+        before1: ['before1', 'before'],
+    };
+    const update = (k) => subUpdater(weaken(updater), root().of(k));
+    return link()
+        .with($setEach(k => to(root().of(k).expr()), dict))
+        .with($setEach(update, dict))
+        .with($replaceWithEach(field => root().of(`${field}1`).expr()))
+        .with($setEach(k => to(nil), dict)).stages;
+};
+
+const $unwindDelta = (k1, k2, k) => {
+    const stages = link()
+        .with(asStages([
+        {
+            $set: {
+                [k1]: {
+                    before: { $ifNull: [`$before.${k1}`, null] },
+                    after: { $ifNull: [`$after.${k1}`, null] },
+                },
+                [k2]: {
+                    $concatArrays: [
+                        {
+                            $map: {
+                                input: { $ifNull: [`$before.${k2}`, []] },
+                                as: 'b',
+                                in: {
+                                    before: '$$b',
+                                    after: {
+                                        $ifNull: [
+                                            {
+                                                $first: {
+                                                    $filter: {
+                                                        input: `$after.${k2}`,
+                                                        as: 'a',
+                                                        cond: { $eq: ['$$a._id', '$$b._id'] },
+                                                    },
+                                                },
+                                            },
+                                            null,
+                                        ],
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            $map: {
+                                input: {
+                                    $filter: {
+                                        input: { $ifNull: [`$after.${k2}`, []] },
+                                        as: 'a',
+                                        cond: {
+                                            $not: {
+                                                $in: [
+                                                    '$$a._id',
+                                                    {
+                                                        $map: {
+                                                            input: { $ifNull: [`$before.${k2}`, []] },
+                                                            as: 'b',
+                                                            in: '$$b._id',
+                                                        },
+                                                    },
+                                                ],
+                                            },
+                                        },
+                                    },
+                                },
+                                as: 'a',
+                                in: { before: null, after: '$$a' },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    ]))
+        .with($unwind_(k2))
+        .with(asStages([
+        {
+            $replaceWith: {
+                _id: "$_id",
+                before: {
+                    $cond: {
+                        if: { $or: [{ $eq: [`$${k1}.before`, null] }, { $eq: [`$${k2}.before`, null] }] },
+                        then: null,
+                        else: {
+                            _id: {
+                                $concat: k
+                                    ? `$${k}.before._id`
+                                    : [
+                                        `$${[k1, k2].sort()[0]}.before._id`,
+                                        '.',
+                                        `$${[k1, k2].sort()[1]}.before._id`,
+                                    ],
+                            },
+                            [k1]: `$${k1}.before`,
+                            [k2]: `$${k2}.before`,
+                        },
+                    },
+                },
+                after: {
+                    $cond: {
+                        if: { $or: [{ $eq: [`$${k1}.after`, null] }, { $eq: [`$${k2}.after`, null] }] },
+                        then: null,
+                        else: {
+                            _id: {
+                                $concat: k
+                                    ? `$${k}.after._id`
+                                    : [
+                                        `$${[k1, k2].sort()[0]}.after._id`,
+                                        '.',
+                                        `$${[k1, k2].sort()[1]}.after._id`,
+                                    ],
+                            },
+                            [k1]: `$${k1}.after`,
+                            [k2]: `$${k2}.after`,
+                        },
+                    },
+                },
+            },
+        },
+    ])).stages;
+    return stages;
+};
+
+const $unwind = (k, dict) => ({
+    delta: link()
+        .with($replaceWithDelta(field({
+        left: ['left', root().expr()],
+        right: ['right', root().of(k).expr()],
+    })))
+        .with($unwindDelta('left', 'right', false))
+        .with($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
+        key: root().of('right').expr(),
+    }, dict)))).stages,
+    raw: $unwind1(k),
+});
+
+const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k) => {
+    return link()
+        .with($replaceWithDelta(field(map1(k1, root().expr()))))
+        .with($simpleLookup_({
+        coll,
+        k: 'a',
+        fields: {
+            foreign: root().of('before').with(field2),
+            local: root().of('after').of(k1).with(field1),
+        },
+        vars: {},
+        pipeline: link().with(input).with(exec).stages,
+    }))
+        .with($simpleLookup_({
+        coll,
+        k: 'b',
+        fields: {
+            foreign: root().of('before').with(field2),
+            local: root().of('before').of(k1).with(field1),
+        },
+        vars: {},
+        pipeline: link().with(input).with(exec).stages,
+    }))
+        .with($replaceWithEach((f) => {
+        const f1 = f === 'after' ? 'a' : 'b';
+        const omit = omitRORec();
+        const a = root().of(f1).of('before').expr();
+        const part = root().of(f);
+        return ite(eq(root().of(f).expr())(nil), nil, field(omit.backward(mergeExpr(omit.forward(map1(k2, a)), map1(k1, part.of(k1).expr())))));
+    }))
+        .with($unwindDelta(k1, k2, k)).stages;
+};
+
+const asBefore = (f) => f(() => root().of('before'));
+
+const createIndex = async (collection, indexSpec, options) => {
+    while (true) {
+        try {
+            await collection.createIndex(indexSpec, options);
+        }
+        catch (e) {
+            if (e.code == 85) {
+                break;
+            }
+            if (e.code == 12587) {
+                await new Promise(res => setTimeout(res, 300));
+                continue;
+            }
+            throw e;
+        }
+        break;
+    }
+};
+
+const patch = (x, k, v) => ({ ...x, [k]: v });
+const restart = (sources) => {
+    return map(sources, x => x.stop());
+};
+const race = async (sources) => {
+    const promises = Object.values(map(sources, ({ next }, key) => next.then(frame => ({ key, sources, frame }))));
+    return Promise.race(promises);
+};
+
+const nextWinner = async (previousWinner, previousWinnerNextFrame, sources, interrupt) => {
+    const { frame: previousFrame, key } = previousWinner;
+    if (!interrupt?.(key) && previousFrame.info.job) {
+        const previousFrameSuccessor = await previousWinnerNextFrame;
+        if (previousFrame.info.job === previousFrameSuccessor.info.job) {
+            return { frame: previousFrameSuccessor, key };
+        }
+    }
+    return race(sources);
+};
+
+const mergeIterators = (params) => {
+    const { sources, interrupt, select = race } = params;
+    const reiterate = (winner) => {
+        const { frame, key } = winner, result = frame.cont();
+        return {
+            cont: () => mergeIterators({
+                sources: patch(sources, key, result),
+                interrupt,
+                select: sources => nextWinner(winner, result.next, sources, interrupt),
+            }),
+            data: frame.data,
+            info: { key, value: frame.info, job: frame.info.job },
+        };
+    };
+    return {
+        stop: () => mergeIterators({ sources: restart(sources), interrupt }),
+        next: select(sources).then(reiterate),
+        clear: async () => {
+            for (const key in sources) {
+                await sources[key].clear();
+            }
+        },
+    };
+};
+
+const firstWorksMerge = (iters) => {
+    const iterator = () => {
+        const results = iters.map(iter => iter());
+        const sources = { ...results };
+        return mergeIterators({
+            sources,
+            interrupt: key => false,
+        });
+    };
+    return iterator;
+};
+
+class Machine {
+    sources;
+    constructor(root) {
+        this.sources = root ? [root] : [];
+    }
+    add(x) {
+        this.sources.push(x);
+    }
+    runner() {
+        const items = this.sources.filter(x => x);
+        if (items.length === 1) {
+            return items[0];
+        }
+        return firstWorksMerge(items);
+    }
+    start(cb) {
+        const run = this.runner();
+        return runCont(run(), cb);
+    }
+}
+const wrap = (root) => new Machine(root.runner());
+const runCont = async ({ next }, cb) => {
+    const { cont, info } = await next;
+    const stopped = cb?.(info);
+    const it = cont();
+    if (stopped) {
+        await it.clear();
+        throw new Error('Machine stopped');
+    }
+    return runCont(it, cb);
+};
+
+const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup) => {
+    createIndex(leftSnapshot.coll, { [lField.str()]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
+    createIndex(rightSnapshot.coll, { [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 resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
+    const dict = { [as]: 'a' };
+    const idB = { _id: 'b' };
+    const dictId = { ...dict, ...idB };
+    return {
+        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);
+            const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId);
+            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));
+            return () => merge({ lsource: lRunner(), rsource: rRunner() });
+        },
+    };
+};
+const $lookup1 = (p) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input)));
+const $lookup = (p) => (l) => $lookup1({
+    right: p.from,
+    as: p.as,
+    lField: p.localField,
+    rField: p.foreignField,
+    left: l(emptyDelta()),
+});
+
+const operator = () => (op) => (operand) => {
+    return {
+        raw: { [op]: operand },
+        expr: (field) => asExpr({
+            raw: f => asExprRaw({ [op]: [$ifNull(field.expr(), nil).raw(f).get(), operand] }),
+        }),
+    };
+};
+
+const dualEq = operator();
+const $eq = dualEq('$eq');
+const $ne = dualEq('$ne');
+const comp = operator();
+const $gt = comp('$gt');
+const $gtTs = comp('$gt');
+const $gteTs = comp('$gte');
+const $lt = comp('$lt');
+const dateLt = comp('$lt');
+const $gte = comp('$gte');
+const $lte = comp('$lte');
+
+const dualIn = operator();
+const $in = dualIn('$in');
+const $nin = dualIn('$nin');
+
+const make = (alter) => {
+    return (op, args) => alter(op, args.filter(defined));
+};
+const combine = (op, make) => (...args) => {
+    const q = make(op, args);
+    return q && { raw: field => q(x => x.raw(field)) };
+};
+const all = (op, x) => (x.length === 0 ? undefined : f => ({ [op]: x.map(f) }));
+const first = (op, x) => (x.length === 1 ? f => f(x[0]) : all(op, x));
+const $and = combine('$and', make(first));
+const $nor = combine('$nor', make(all));
+const $or = combine('$or', make(first));
+
+const $matchDelta = (query) => concatStages($replaceWithDelta(ite(query, root().expr(), nil)), $match_($or(root().of('after').has($ne(null)), root().of('before').has($ne(null)))));
+
+const $match = (query) => ({
+    raw: $match1($expr(query)),
+    delta: $matchDelta(query),
+});
+
+const $setCore = (updater) => ({
+    delta: $setDelta(updater),
+    raw: $set1(updater),
+    lin: $set_(updater),
+});
+const $set = () => (fields) => {
+    return $setCore(set()(fields));
+};
+const $replaceWith = (expr) => ({
+    delta: $replaceWithDelta(expr),
+    raw: $replaceWith1(expr),
+    lin: $replaceWith_(expr),
+});
+
+const $merge = () => (out, keys) => {
+    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', root().of('_id').expr()],
+        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 $upsert = (out) => {
+    const replacer = ite(eqTyped(root().of('after').expr(), nil), field({
+        deletedAt: ['deletedAt', current],
+        _id: ['_id', root().of('_id').expr()],
+        touchedAt: ['touchedAt', current],
+    }), mergeObjects(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 T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
+const replace = (s) => s.replace(/\{"\$timestamp":"(\d+)"\}/g, (_, d) => T(d));
+const json = (a) => replace(JSON.stringify(a));
+const log = (...args) => console.log(new Date(), ...args.map(a => (typeof a === 'function' ? a(replace) : a && typeof a === 'object' ? json(a) : a)));
+
+const aggregate = (input, snapshot = true, start = Date.now()) => input(({ coll, input }) => {
+    const req = {
+        aggregate: coll.collectionName,
+        pipeline: input,
+        cursor: {},
+        ...(snapshot && { readConcern: { level: 'snapshot' } }),
+    };
+    log('exec', req);
+    return coll.s.db.command(req).then(result => {
+        log('execed', req, result, 'took', Date.now() - start);
+        return result;
+    }, err => {
+        log('err', req);
+        throw new Error(err);
+    });
+});
+
+const addTeardown = (it, tr) => {
+    if (!tr)
+        return it;
+    return () => {
+        const { next, stop, clear } = it();
+        const n = next;
+        return {
+            next: n.then(({ cont, ...res }) => ({ cont: addTeardown(cont, tr), ...res })),
+            stop: () => (tr(), stop()),
+            clear: async () => {
+                tr();
+                await clear();
+            },
+        };
+    };
+};
+
+const changeKeys = ['fullDocument', 'fullDocumentBeforeChange'];
+const subQ = (a, f) => ({ raw: g => a.raw(g.with(f)) });
+const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startAt) => {
+    const projection = mapExactToObject(p, v => v);
+    const pipeline = [];
+    if (m) {
+        const q = $or(...changeKeys.map((k) => subQ(m, root().of(k))));
+        if (q)
+            pipeline.push({
+                $match: { $or: [q.raw(root()), Object.fromEntries(changeKeys.map(k => [k, null]))] },
+            });
+    }
+    pipeline.push({
+        $project: {
+            _id: 1,
+            fullDocument: projection,
+            fullDocumentBeforeChange: projection,
+            documentKey: 1,
+            clusterTime: 1,
+        },
+    });
+    pipeline.push({
+        $match: {
+            $or: [
+                { $expr: { $ne: ['$fullDocument', '$fullDocumentBeforeChange'] } },
+                Object.fromEntries(changeKeys.map(k => [k, null])),
+            ],
+        },
+    });
+    const stream = db.collection(collection.collectionName).watch(pipeline, {
+        fullDocument: 'required',
+        fullDocumentBeforeChange: 'required',
+        startAtOperationTime: startAt,
+    });
+    const tryNext = async () => {
+        const doc = await stream.tryNext();
+        if (doc)
+            await new Promise(resolve => setTimeout(resolve, 100));
+        return doc;
+    };
+    return { tryNext, close: () => stream.close() };
+};
+
+const streamNames = {};
+const executes$1 = (view, input, streamName) => {
+    const hash = crypto
+        .createHash('md5')
+        .update(new Error().stack + '')
+        .digest('base64url');
+    if (!streamNames[streamName])
+        streamNames[streamName] = hash;
+    else if (streamNames[streamName] != hash)
+        throw new Error(`streamName ${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 }, hardMatch
+        ? {
+            partialFilterExpression: hardMatch,
+            name: 'touchedAt_hard_' + new mongodb.UUID().toString('base64'),
+        }
+        : {}).catch(e => e.code == 86 || Promise.reject(e));
+    const last = db.collection('__last');
+    const snapshotCollection = db.collection(coll + '_' + streamName + '_snapshot');
+    createIndex(snapshotCollection, { updated: 1 }, {
+        partialFilterExpression: { updated: true },
+        name: 'updated_' + new mongodb.UUID().toString('base64'),
+    });
+    createIndex(snapshotCollection, { updated: 1 }, {
+        partialFilterExpression: { updated: true, after: null, before: null },
+        name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
+    });
+    const projectInput = $project_(spread(projection, {
+        deletedAt: ['deletedAt', 1],
+        _id: ['_id', 1],
+    }));
+    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, '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 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);
+            const query = match ? and(notDeleted, match) : notDeleted;
+            const replaceRaw = $replaceWith_(field({
+                after: ['after', ite(query, root().expr(), nil)],
+                updated: ['updated', val(true)],
+                _id: ['_id', root().of('_id').expr()],
+            }));
+            const cloneIntoNew = link()
+                .with($match_(hardQuery))
+                .with(projectInput)
+                .with(replaceRaw)
+                .with($merge_({
+                into: snapshotCollection,
+                on: root().of('_id'),
+                whenMatched: 'merge',
+                whenNotMatched: 'insert',
+            })).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');
+        };
+        const makeStream = (startAt) => makeWatchStream(db, view, startAt);
+        const step4 = (result) => async () => {
+            const start = Date.now();
+            await snapshotCollection.updateMany({ before: null }, { $set: { before: null } });
+            const aggResult = await aggregate(c => c({
+                coll: snapshotCollection,
+                input: link()
+                    .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,
+            }), false, start);
+            const stream = makeStream(result.cursor.atClusterTime);
+            return next(step5({ result, aggResult, stream }), 'remove handled deleted updated', () => stream.close());
+        };
+        const step5 = (l) => async () => {
+            log(`remove handled deleted updated db['${snapshotCollection.collectionName}'].deleteMany({ updated: true, after: null })`);
+            await snapshotCollection.deleteMany({ updated: true, after: null });
+            log('removed handled deleted updated');
+            return next(step6(l), 'update snapshot aggregation');
+        };
+        const step6 = (l) => async () => {
+            log('update snapshot aggregation', `db['${snapshotCollection.collectionName}'].updateMany({ updated: true }, [ { $set: { updated: false, after: null, before: '$after' } } ])`);
+            await snapshotCollection.updateMany({ updated: true }, [
+                {
+                    $set: {
+                        updated: false,
+                        after: null,
+                        before: '$after',
+                    },
+                },
+            ]);
+            log('updated snapshot aggregation');
+            return next(step7(l), 'update __last');
+        };
+        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(step2, 'restart') : step8(l)))),
+            };
+        };
+        return stop;
+    };
+    const hasBefore = root().of('before').has($ne(null));
+    return {
+        stages: c => c({
+            coll: snapshotCollection,
+            input: $match_(hasBefore),
+            exec: asBefore(input.raw),
+        }),
+        out: run,
+    };
+};
+const staging = (view, streamName) => pipe(input => executes$1(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
+
+const executes = (view, input, streamName) => {
+    const hash = crypto
+        .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 dayAndMonthPart = (date) => asExpr({
+    raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%m-%d' } }),
+});
+const now = () => asExpr({
+    raw: f => asExprRaw('$$NOW'),
+});
+const monthPart = (date) => asExpr({
+    raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%Y-%m' } }),
+});
+const dateAdd = (date, amount, unit) => asExpr({
+    raw: f => asExprRaw({
+        $dateAdd: {
+            startDate: date.raw(f).get(),
+            unit: unit.raw(f).get(),
+            amount: amount.raw(f).get(),
+        },
+    }),
+});
+const maxDate = (expr) => asExpr({
+    raw: f => asExprRaw({ $max: expr.raw(f).get() }),
+});
+const minDate = (expr) => asExpr({
+    raw: f => asExprRaw({ $min: expr.raw(f).get() }),
+});
+const datePart = (date) => asExpr({
+    raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%Y-%m-%d' } }),
+});
+const startOf = (startDate, freq, offset) => asExpr({
+    raw: f => asExprRaw({
+        $let: {
+            vars: { d: startDate.raw(f).get(), f: freq.raw(f).get(), i: offset.raw(f).get() },
+            in: {
+                $switch: {
+                    branches: [
+                        {
+                            case: { $eq: ['$$f', 'week'] },
+                            then: {
+                                $dateFromParts: {
+                                    isoWeekYear: { $isoWeekYear: '$$d' },
+                                    isoWeek: {
+                                        $add: [
+                                            { $isoWeek: '$$d' },
+                                            {
+                                                $cond: {
+                                                    if: {
+                                                        $lt: ['$$i', { $isoDayOfWeek: '$$d' }],
+                                                    },
+                                                    then: 1,
+                                                    else: 0,
+                                                },
+                                            },
+                                        ],
+                                    },
+                                    isoDayOfWeek: '$$i',
+                                },
+                            },
+                        },
+                        {
+                            case: { $eq: ['$$f', 'month'] },
+                            then: {
+                                $dateFromParts: {
+                                    year: { $year: '$$d' },
+                                    month: {
+                                        $add: [
+                                            { $month: '$$d' },
+                                            {
+                                                $cond: {
+                                                    if: {
+                                                        $lt: ['$$i', { $dayOfMonth: '$$d' }],
+                                                    },
+                                                    then: 1,
+                                                    else: 0,
+                                                },
+                                            },
+                                        ],
+                                    },
+                                    day: '$$i',
+                                },
+                            },
+                        },
+                        {
+                            case: { $eq: ['$$f', 'year'] },
+                            then: {
+                                $dateFromParts: {
+                                    year: {
+                                        $add: [
+                                            { $year: '$$d' },
+                                            {
+                                                $cond: {
+                                                    if: {
+                                                        $or: [
+                                                            {
+                                                                $lt: [{ $floor: { $divide: ['$$i', 100] } }, { $month: '$$d' }],
+                                                            },
+                                                            {
+                                                                $and: [
+                                                                    {
+                                                                        $eq: [
+                                                                            { $floor: { $divide: ['$$i', 100] } },
+                                                                            { $month: '$$d' },
+                                                                        ],
+                                                                    },
+                                                                    {
+                                                                        $lt: [{ $mod: ['$$i', 100] }, { $dayOfMonth: '$$d' }],
+                                                                    },
+                                                                ],
+                                                            },
+                                                        ],
+                                                    },
+                                                    then: 1,
+                                                    else: 0,
+                                                },
+                                            },
+                                        ],
+                                    },
+                                    month: { $floor: { $divide: ['$$i', 100] } },
+                                    day: { $mod: ['$$i', 100] },
+                                },
+                            },
+                        },
+                    ],
+                    default: {
+                        $dateFromParts: {
+                            year: { $year: '$$d' },
+                            month: { $month: '$$d' },
+                            day: { $add: [{ $dayOfMonth: '$$d' }, '$$i'] },
+                        },
+                    },
+                },
+            },
+        },
+    }),
+});
+const dateDiff = ({ end, unit, start, }) => asExpr({
+    raw: f => asExprRaw({
+        $let: {
+            vars: {
+                f: unit.raw(f).get(),
+                end: end.raw(f).get(),
+                start: start.raw(f).get(),
+            },
+            in: {
+                $let: {
+                    vars: {
+                        diff: {
+                            $dateDiff: {
+                                startDate: '$$start',
+                                endDate: '$$end',
+                                unit: '$$f',
+                            },
+                        },
+                    },
+                    in: {
+                        $switch: {
+                            branches: [
+                                {
+                                    case: { $eq: ['$$f', 'month'] },
+                                    then: {
+                                        $cond: {
+                                            if: {
+                                                $lte: [{ $dayOfMonth: '$$start' }, { $dayOfMonth: '$$end' }],
+                                            },
+                                            then: '$$diff',
+                                            else: { $subtract: ['$$diff', 1] },
+                                        },
+                                    },
+                                },
+                                {
+                                    case: { $eq: ['$$f', 'week'] },
+                                    then: {
+                                        $cond: {
+                                            if: {
+                                                $lte: [{ $isoDayOfWeek: '$$start' }, { $isoDayOfWeek: '$$end' }],
+                                            },
+                                            then: '$$diff',
+                                            else: { $subtract: ['$$diff', 1] },
+                                        },
+                                    },
+                                },
+                                {
+                                    case: { $eq: ['$$f', 'year'] },
+                                    then: {
+                                        $cond: {
+                                            if: {
+                                                $or: [
+                                                    {
+                                                        $lt: [{ $month: '$$start' }, { $month: '$$end' }],
+                                                    },
+                                                    {
+                                                        $and: [
+                                                            {
+                                                                $eq: [{ $month: '$$start' }, { $month: '$$end' }],
+                                                            },
+                                                            {
+                                                                $lte: [{ $dayOfMonth: '$$start' }, { $dayOfMonth: '$$end' }],
+                                                            },
+                                                        ],
+                                                    },
+                                                ],
+                                            },
+                                            then: '$$diff',
+                                            else: { $subtract: ['$$diff', 1] },
+                                        },
+                                    },
+                                },
+                            ],
+                            default: '$$diff',
+                        },
+                    },
+                },
+            },
+        },
+    }),
+});
+
+const range = (start, end, step) => asExpr({
+    raw: f => asExprRaw({ $range: [start.raw(f).get(), end.raw(f).get(), step?.raw(f).get() ?? 1] }),
+});
+const $map1 = (ex, map) => asExpr({
+    raw: f => asExprRaw({
+        $map: {
+            input: ex.raw(f).get(),
+            as: 'item',
+            in: map(ctx()('item')).raw(f).get(),
+        },
+    }),
+});
+const $map = (ex, map) => $map1(ex, i => map(i.expr()));
+
+require('dotenv').config();
+const uri = process.env['MONGO_URL'];
+
+const enablePreAndPostImages = (coll) => coll.s.db.command({
+    collMod: coll.collectionName,
+    changeStreamPreAndPostImages: { enabled: true },
+});
+const prepare = async (testName) => {
+    const client = new mongodb.MongoClient(uri, testName ? { monitorCommands: true } : {});
+    if (testName) {
+        const handler = (c) => {
+            promises.writeFile(`./out/${testName}.log`, JSON.stringify(c.command) + ',\n', { flag: 'w' });
+        };
+        client.on('commandStarted', handler);
+        client.on('commandSucceeded', handler);
+    }
+    await client.connect();
+    await client.db('admin').command({
+        setClusterParameter: {
+            changeStreamOptions: {
+                preAndPostImages: { expireAfterSeconds: 60 },
+            },
+        },
+    });
+    return client;
+};
+
+exports.$accumulator = $accumulator;
+exports.$and = $and;
+exports.$countDict = $countDict;
+exports.$entries = $entries;
+exports.$eq = $eq;
+exports.$expr = $expr;
+exports.$getField = $getField;
+exports.$group = $group;
+exports.$groupId = $groupId;
+exports.$groupMerge = $groupMerge;
+exports.$gt = $gt;
+exports.$gtTs = $gtTs;
+exports.$gte = $gte;
+exports.$gteTs = $gteTs;
+exports.$ifNull = $ifNull;
+exports.$in = $in;
+exports.$keys = $keys;
+exports.$let = $let;
+exports.$lookup = $lookup;
+exports.$lt = $lt;
+exports.$lte = $lte;
+exports.$map = $map;
+exports.$map1 = $map1;
+exports.$match = $match;
+exports.$matchDelta = $matchDelta;
+exports.$merge = $merge;
+exports.$merge_ = $merge_;
+exports.$ne = $ne;
+exports.$nin = $nin;
+exports.$nor = $nor;
+exports.$or = $or;
+exports.$pushDict = $pushDict;
+exports.$rand = $rand;
+exports.$replaceWith = $replaceWith;
+exports.$set = $set;
+exports.$sum = $sum;
+exports.$unwind = $unwind;
+exports.$unwindDelta = $unwindDelta;
+exports.$upsert = $upsert;
+exports.Field = Field;
+exports.Machine = Machine;
+exports.add = add;
+exports.and = and;
+exports.array = array;
+exports.ceil = ceil;
+exports.comp = comp;
+exports.concat = concat;
+exports.ctx = ctx;
+exports.current = current;
+exports.dateAdd = dateAdd;
+exports.dateDiff = dateDiff;
+exports.dateLt = dateLt;
+exports.datePart = datePart;
+exports.dayAndMonthPart = dayAndMonthPart;
+exports.divide = divide;
+exports.enablePreAndPostImages = enablePreAndPostImages;
+exports.eq = eq;
+exports.eqTyped = eqTyped;
+exports.except = except;
+exports.exprMapVal = exprMapVal;
+exports.filter = filter;
+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;
+exports.inArray = inArray;
+exports.isArray = isArray;
+exports.ite = ite;
+exports.last = last;
+exports.lt = lt;
+exports.lte = lte;
+exports.mapVal = mapVal;
+exports.max = max;
+exports.maxDate = maxDate;
+exports.mergeObjects = mergeObjects;
+exports.minDate = minDate;
+exports.monthPart = monthPart;
+exports.multiply = multiply;
+exports.ne = ne;
+exports.nil = nil;
+exports.notNull = notNull;
+exports.now = now;
+exports.prepare = prepare;
+exports.rand = rand;
+exports.range = range;
+exports.root = root;
+exports.setField = setField;
+exports.size = size;
+exports.slice = slice;
+exports.sortArray = sortArray;
+exports.staging = staging;
+exports.startOf = startOf;
+exports.sub = sub;
+exports.subtract = subtract;
+exports.val = val;
+exports.wrap = wrap;