@omegup/msync 0.1.60 → 0.1.62

package/index.js

@@ -1,592 +1,457 @@
-'use strict';
-
-var mongodb = require('mongodb');
-var crypto$1 = require('crypto');
-var jsonCanonicalize = require('json-canonicalize');
-var promises = require('fs/promises');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let mongodb = require("mongodb");
+let crypto$1 = require("crypto");
+crypto$1 = __toESM(crypto$1, 1);
+let json_canonicalize = require("json-canonicalize");
+let fs_promises = require("fs/promises");
+//#region .build/lib/expression/expr-base.js
 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 min = (...expr) => asExpr({
-    raw: f => asExprRaw({ $min: 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()) }),
-});
+//#endregion
+//#region .build/lib/expression/arith.js
+const max = (...expr) => asExpr({ raw: (f) => asExprRaw({ $max: expr.map((e) => e.raw(f).get()) }) });
+const min = (...expr) => asExpr({ raw: (f) => asExprRaw({ $min: 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()) }),
-    });
+	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()) }),
-    });
+	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()) }),
-    });
+	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()) }),
-    });
+	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() }),
-    });
+	return asExpr({ raw: (f) => asExprRaw({ $floor: expr.raw(f).get() }) });
 }
 function ceil(expr) {
-    return asExpr({
-        raw: f => asExprRaw({ $ceil: expr.raw(f).get() }),
-    });
+	return asExpr({ raw: (f) => asExprRaw({ $ceil: expr.raw(f).get() }) });
 }
-
+//#endregion
+//#region .build/lib/utils/json.js
+const safeNarrow = () => {
+	return (x) => x;
+};
 const id$1 = (x) => x;
 const defined = (x) => x != null;
-const noop = () => { };
+const noop = () => {};
 const map1 = (k, to) => {
-    const k2 = k;
-    return { [k]: [k2, to] };
+	const k2 = k;
+	return { [k]: [k2, to] };
 };
-
+//#endregion
+//#region .build/lib/utils/map-object.js
 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 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 spread0 = (a, b) => ({ ...a, ...mapExact0(b, id$1) });
-
-const val = (val) => asExpr({
-    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) ||
-        (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 spread = (a, b) => ({
+	...a,
+	...mapExact(b, id$1)
+});
+const spread0 = (a, b) => ({
+	...a,
+	...mapExact0(b, id$1)
+});
+//#endregion
+//#region .build/lib/expression/val.js
+const val = (val) => asExpr({ raw: () => asExprRaw(val && typeof val === "object" && !(val instanceof Date) || 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 $getField = (expr, field) => asExpr({ raw: (f) => asExprRaw({ $getField: {
+	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 or = (...expr) => asExpr({
-    raw: f => asExprRaw({ $or: expr.map(e => e.raw(f).get()) }),
-});
-const not = (expr) => asExpr({
-    raw: f => asExprRaw({ $not: expr.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()] }),
-});
+//#endregion
+//#region .build/lib/expression/logic.js
+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 or = (...expr) => asExpr({ raw: (f) => asExprRaw({ $or: expr.map((e) => e.raw(f).get()) }) });
+const not = (expr) => asExpr({ raw: (f) => asExprRaw({ $not: expr.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 $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]) => safeNarrow()({
+		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 setField = ({ field, input, value }) => asExpr({ raw: (f) => asExprRaw({ $setField: {
+	field: field.raw(f).get(),
+	input: input.raw(f).get(),
+	value: value.raw(f).get()
+} }) });
+//#endregion
+//#region .build/lib/field/field.js
+var Field = 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;
-
+//#endregion
+//#region .build/lib/accumulators/index.js
 const asAccumulator = (x) => x;
-const $sum_ = (expr) => ({ raw: f => asAccumulator({ $sum: expr.raw(f).get() }) });
+const $sum_ = (expr) => ({ raw: (f) => asAccumulator({ $sum: expr.raw(f).get() }) });
 const $sum = (expr) => ({
-    group: $sum_(ite(root().of('deleted').expr(), val(0), 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),
+	group: $sum_(ite(root().of("deleted").expr(), val(0), 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',
-            },
-        }),
-    };
+	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),
+	group: $accumulator_(init, accumulateArgs, accumulate, merge),
+	merge: (a, b) => func(merge, a, b)
 });
-const $countDict = (expr) => $accumulator(function () {
-    return {};
+const $countDict = (expr) => $accumulator(function() {
+	return {};
 }, [
-    sub(expr, root().of('v')),
-    root().of('old').expr(),
-    root().of('deleted').expr(),
-], function (a, k, old, deleted) {
-    if (deleted)
-        return a;
-    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 $countDictArray = (expr) => $accumulator(function () {
-    return {};
+	sub(expr, root().of("v")),
+	root().of("old").expr(),
+	root().of("deleted").expr()
+], function(a, k, old, deleted) {
+	if (deleted) return a;
+	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 $countDictArray = (expr) => $accumulator(function() {
+	return {};
 }, [
-    sub(expr, root().of('v')),
-    root().of('old').expr(),
-    root().of('deleted').expr(),
-], function (a, keys, old, deleted) {
-    if (deleted)
-        return a;
-    keys.forEach(k => {
-        const y = (a[k] || 0) + (old ? -1 : 1);
-        if (y)
-            a[k] = y;
-        else
-            delete a[k];
-    });
-    return 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(expr, root().of("v")),
+	root().of("old").expr(),
+	root().of("deleted").expr()
+], function(a, keys, old, deleted) {
+	if (deleted) return a;
+	keys.forEach((k) => {
+		const y = (a[k] || 0) + (old ? -1 : 1);
+		if (y) a[k] = y;
+		else delete a[k];
+	});
+	return 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(),
-    root().of('deleted').expr(),
-], function (ra, k, v, old, deleted) {
-    if (deleted)
-        return ra;
-    let a = { ...ra };
-    const equal = (a, b) => {
-        if (!a || !b)
-            return a === b;
-        if (a instanceof Date)
-            return b instanceof Date && a.getTime() === b.getTime();
-        if ([a, b].some(a => Object.getPrototypeOf(a) != Object.prototype))
-            return a.valueOf() === b.valueOf();
-        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);
+	sub(key, root().of("v")),
+	sub(value, root().of("v")),
+	root().of("old").expr(),
+	root().of("deleted").expr()
+], function(ra, k, v, old, deleted) {
+	if (deleted) return ra;
+	let a = { ...ra };
+	const equal = (a, b) => {
+		if (!a || !b) return a === b;
+		if (a instanceof Date) return b instanceof Date && a.getTime() === b.getTime();
+		if ([a, b].some((a) => Object.getPrototypeOf(a) != Object.prototype)) return a.valueOf() === b.valueOf();
+		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 })));
+const $entries = (expr) => func(function(obj) {
+	return Object.entries({ ...obj }).flatMap(([k, v]) => v[0].map((v) => ({
+		k,
+		v
+	})));
 }, expr);
-
+//#endregion
+//#region .build/lib/aggregate/prefix.js
 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)),
+	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;
+	return {
+		with: (map) => pipe(map((i) => stream(concat(s, i))), empty(), concat, empty),
+		then: (next) => pipe(stream, concat(s, next), concat, empty),
+		get: () => stream(s)
+	};
 };
 const concat$1 = (stages) => ({
-    with: extra => concat$1(concatStages(stages, extra)),
-    stages,
+	with: (extra) => concat$1(concatStages(stages, extra)),
+	stages
 });
 const link = () => ({
-    with: extra => concat$1(extra),
-    stages: asStages([]),
+	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 concat = (...expr) => asExpr({
-    raw: f => asExprRaw({ $concat: expr.map(e => e.raw(f).get()) }),
-});
-const $substr = (expr, start, length) => asExpr({
-    raw: f => asExprRaw({
-        $substrCP: [expr.raw(f).get(), start.raw(f).get(), length.raw(f).get()],
-    }),
-});
-const padLeft = (expr, pad) => asExpr({
-    raw: f => asExprRaw({
-        $let: {
-            vars: {
-                x: {
-                    $concat: [{ $literal: pad }, expr.raw(f).get()],
-                },
-            },
-            in: { $substrCP: ['$$x', { $subtract: [{ $strLenCP: '$$x' }, pad.length] }, pad.length] },
-        },
-    }),
-});
-const regex = (expr, regex, options) => asExpr({
-    raw: f => asExprRaw({
-        $regexMatch: {
-            input: expr.raw(f).get(),
-            regex: regex.raw(f).get(),
-            options: options?.raw(f).get(),
-        },
-    }),
-});
-const str = (expr) => asExpr({
-    raw: f => asExprRaw({ $toString: expr.raw(f).get() }),
-});
-const toInt = (expr) => asExpr({
-    raw: f => asExprRaw({ $toInt: expr.raw(f).get() }),
-});
-const fieldM = (expr, m) => asExpr({
-    raw: (f) => asExprRaw(Object.fromEntries(Object.entries(m).flatMap(([dom, ref]) => expr[ref] ? [[dom, expr[ref].raw(f).get()]] : []))),
-});
+	delta: link().stages,
+	raw: () => link().stages
+});
+const concatTStages = ({ coll, exec, input }, stages) => ({
+	coll,
+	input,
+	exec: concatStages(exec, stages)
+});
+//#endregion
+//#region .build/lib/expression/concat.js
+const concat = (...expr) => asExpr({ raw: (f) => asExprRaw({ $concat: expr.map((e) => e.raw(f).get()) }) });
+const $substr = (expr, start, length) => asExpr({ raw: (f) => asExprRaw({ $substrCP: [
+	expr.raw(f).get(),
+	start.raw(f).get(),
+	length.raw(f).get()
+] }) });
+const padLeft = (expr, pad) => asExpr({ raw: (f) => asExprRaw({ $let: {
+	vars: { x: { $concat: [{ $literal: pad }, expr.raw(f).get()] } },
+	in: { $substrCP: [
+		"$$x",
+		{ $subtract: [{ $strLenCP: "$$x" }, pad.length] },
+		pad.length
+	] }
+} }) });
+const regex = (expr, regex, options) => asExpr({ raw: (f) => asExprRaw({ $regexMatch: {
+	input: expr.raw(f).get(),
+	regex: regex.raw(f).get(),
+	options: options?.raw(f).get()
+} }) });
+const str = (expr) => asExpr({ raw: (f) => asExprRaw({ $toString: expr.raw(f).get() }) });
+const toInt = (expr) => asExpr({ raw: (f) => asExprRaw({ $toInt: expr.raw(f).get() }) });
+const fieldM = (expr, m) => asExpr({ raw: (f) => asExprRaw(Object.fromEntries(Object.entries(m).flatMap(([dom, ref]) => expr[ref] ? [[dom, expr[ref].raw(f).get()]] : []))) });
 const mergeExact = (...[exprsExact1, exprsExact2]) => spread(exprsExact1, exprsExact2);
 const mergeExact0 = (...[exprsExact1, exprsExact2]) => spread0(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 fieldF = () => (exprs) => Object.keys(exprs).length ? asExpr({ raw: (f) => asExprRaw(mapExactToObject(exprs, (e) => e.raw(f).get())) }) : asExpr(val(safeNarrow()({})));
 const field = fieldF();
-
-const sym = (eq) => ({
-    backward: eq.forward,
-    forward: eq.backward,
-    backward1: eq.forward1,
-    forward1: eq.backward1,
-});
-const reflex = () => ({
-    backward: id,
-    forward: id,
-    backward1: id,
-    forward1: id,
-});
-const id = (x) => x;
-const assertEqual = () => reflex();
-const eqExtends = (_1, _2) => assertEqual();
-const fromEq = (eq) => ({
-    ...eq,
-    backward1: (eq.backward),
-    forward1: (eq.forward),
-});
-const literalsEqaul = (_) => assertEqual();
-const omitRORec = () => assertEqual();
-const omitPick = () => assertEqual();
-const omitExclude = () => assertEqual();
-const renamedFields = () => assertEqual();
-const translateOmit = () => assertEqual();
-const excludeIdem = () => assertEqual();
-const eqPar = () => assertEqual();
-
-const size = (expr) => asExpr({
-    raw: f => asExprRaw({ $size: expr.raw(f).get() }),
-});
+//#endregion
+//#region .build/lib/expression/array.js
+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: 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 inArray = (item, expr) => asExpr({
-    raw: f => asExprRaw({ $in: [item.raw(f).get(), expr.raw(f).get()] }),
-});
-const array = (...exprs) => asExpr({
-    raw: f => asExprRaw(exprs.map(x => x.raw(f).get())),
-});
-const concatArray = (...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 anyElementTrue = (expr) => asExpr({
-    raw: f => asExprRaw({ $anyElementTrue: expr.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()],
-    }),
-});
+	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: 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 inArray = (item, expr) => asExpr({ raw: (f) => asExprRaw({ $in: [item.raw(f).get(), expr.raw(f).get()] }) });
+const array = (...exprs) => asExpr({ raw: (f) => asExprRaw(exprs.map((x) => x.raw(f).get())) });
+const concatArray = (...exprs) => asExpr({ raw: (f) => asExprRaw({ $concatArrays: exprs.map((x) => x.raw(f).get()) }) });
+const first = (expr) => asExpr({ raw: (f) => asExprRaw({ $first: expr.raw(f).get() }) });
+const firstSure = first;
+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 anyElementTrue = (expr) => asExpr({ raw: (f) => asExprRaw({ $anyElementTrue: expr.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',
-                    concatArray(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except))),
-                ],
-            }), field({
-                out: ['out', concatArray(out, array(curr))],
-                except: ['except', except],
-            })))),
-        ],
-    }, ctx()('res').of('out').expr());
+	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", concatArray(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except)))]
+	}), field({
+		out: ["out", concatArray(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, includeNull) => f => {
-    const path = `$${f().of(k).str()}`;
-    return asStages([
-        { $unwind: includeNull === null ? { path, preserveNullAndEmptyArrays: true } : path },
-    ]);
-};
-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;
-    const letVars = rawVars(vars, f());
-    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(),
-                ...(Object.keys(letVars).length > 0 && { let: letVars }),
-                ...etc,
-            },
-        },
-    ]);
+//#endregion
+//#region .build/lib/aggregate/raws.js
+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, includeNull) => (f) => {
+	const path = `$${f().of(k).str()}`;
+	return asStages([{ $unwind: includeNull === null ? {
+		path,
+		preserveNullAndEmptyArrays: true
+	} : path }]);
+};
+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;
+	const letVars = rawVars(vars, f());
+	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(),
+		...Object.keys(letVars).length > 0 && { let: letVars },
+		...etc
+	} }]);
+};
+//#endregion
+//#region .build/lib/aggregate/mongo-stages.js
 const $match_ = (query) => $match1(query)(root);
 const $set_ = (updater) => $set1(updater)(root);
 const $replaceWith_ = (expr) => $replaceWith1(expr)(root);
@@ -594,1844 +459,1745 @@ const $unwind_ = (k, includeNull) => $unwind1(k, includeNull)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
-
+//#endregion
+//#region .build/lib/aggregate/group/utils/sub-group.js
 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)],
-        deleted: [
-            'deleted',
-            root()
-                .of('deleted')
-                .of('after')
-                .expr(),
-        ],
-    })), ite(eqTyped(root().of('before').expr(), nil), nil, field({
-        v: ['v', root().of('before').expr()],
-        old: ['old', val(true)],
-        deleted: [
-            'deleted',
-            root()
-                .of('deleted')
-                .of('before')
-                .expr(),
-        ],
-    }))));
-    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 part = filterDefined(array(ite(eqTyped(root().of("after").expr(), nil), nil, field({
+		v: ["v", root().of("after").expr()],
+		old: ["old", val(false)],
+		deleted: ["deleted", root().of("deleted").of("after").expr()]
+	})), ite(eqTyped(root().of("before").expr(), nil), nil, field({
+		v: ["v", root().of("before").expr()],
+		old: ["old", val(true)],
+		deleted: ["deleted", root().of("deleted").of("before").expr()]
+	}))));
+	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 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 weekPart = (date) => asExpr({
-    raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%Y-%U' } }),
-});
-const year = (date) => asExpr({
-    raw: f => asExprRaw({ $year: date.raw(f).get() }),
-});
-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 mapFromPlainDateTime = ({ plainDate, timezone, }) => asExpr({
-    raw: f => asExprRaw({
-        $dateFromString: {
-            dateString: {
-                $dateToString: { date: plainDate.raw(f).get(), timezone: 'GMT' },
-            },
-            timezone: timezone.raw(f).get(),
-        },
-    }),
-});
-const mapToPlainDateTime = (date, timezone) => asExpr({
-    raw: f => asExprRaw({
-        $dateFromString: {
-            $dateToString: {
-                date: date.raw(f).get(),
-                timezone: timezone.raw(f).get(),
-            },
-        },
-    }),
-});
-
-const range = (start, end, step) => asExpr({
-    raw: f => asExprRaw({ $range: [start.raw(f).get(), end.raw(f).get(), step?.raw(f).get() ?? 1] }),
-});
-const $map0 = ({ as, expr, input, }) => asExpr({
-    raw: f => asExprRaw({
-        $map: {
-            input: input.raw(f).get(),
-            as,
-            in: expr.raw(f).get(),
-        },
-    }),
-});
-const $map1 = (ex, map) => $map0({ input: ex, as: 'item', expr: map(ctx()('item')) });
-const $map = (ex, map) => $map1(ex, i => map(i.expr()));
-
+//#endregion
+//#region .build/lib/expression/date.js
+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 weekPart = (date) => asExpr({ raw: (f) => asExprRaw({ $dateToString: {
+	date: date.raw(f).get(),
+	format: "%Y-%U"
+} }) });
+const year = (date) => asExpr({ raw: (f) => asExprRaw({ $year: date.raw(f).get() }) });
+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 mapFromPlainDateTime = ({ plainDate, timezone }) => asExpr({ raw: (f) => asExprRaw({ $dateFromString: {
+	dateString: { $dateToString: {
+		date: plainDate.raw(f).get(),
+		timezone: "GMT"
+	} },
+	timezone: timezone.raw(f).get()
+} }) });
+const mapToPlainDateTime = (date, timezone) => asExpr({ raw: (f) => asExprRaw({ $dateFromString: { $dateToString: {
+	date: date.raw(f).get(),
+	timezone: timezone.raw(f).get()
+} } }) });
+//#endregion
+//#region .build/lib/expression/range.js
+const range = (start, end, step) => asExpr({ raw: (f) => asExprRaw({ $range: [
+	start.raw(f).get(),
+	end.raw(f).get(),
+	step?.raw(f).get() ?? 1
+] }) });
+const $map0 = ({ as, expr, input }) => asExpr({ raw: (f) => asExprRaw({ $map: {
+	input: input.raw(f).get(),
+	as,
+	in: expr.raw(f).get()
+} }) });
+const $map1 = (ex, map) => $map0({
+	input: ex,
+	as: "item",
+	expr: map(ctx()("item"))
+});
+const $map = (ex, map) => $map1(ex, (i) => map(i.expr()));
+//#endregion
+//#region .build/lib/update/updater.js
 const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
 const rawSet = (fields) => (f) => {
-    return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+	return Object.entries(mapExactToObject0(fields, (v) => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
 };
-const set = () => (fields) => ({
-    raw: rawSet(fields),
-});
+const set = () => (fields) => ({ raw: rawSet(fields) });
 const setQ = () => {
-    return (fields) => ({
-        raw: rawSet(fields),
-    });
+	return (fields) => ({ raw: rawSet(fields) });
 };
-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 weaken = (updater) => ({ raw: (f) => updater.raw(f) });
+const to = (expr) => ({ raw: (f) => [["", expr.raw(f).get()]] });
+//#endregion
+//#region .build/lib/utils/coll.js
+const dbcoll = (x) => safeNarrow()({
+	db: x.dbName,
+	coll: x.collectionName
+});
+//#endregion
+//#region .build/lib/aggregate/out.js
+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 $merge2 = (args) => $merge_(args);
-
-const getWhenMatchedForMerge = (whenNotMatched, update) => {
-    const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
-    const newOrOld = whenNotMatched ===
-        'insert'
-        ? ctx()('new')
-        : root();
-    const merged = mergeObjects(root().expr(), update(ctx()('new').expr(), root().expr()), field({
-        deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
-    }));
-    return link()
-        .with($replaceWith_(field({
-        old: ['old', root().expr()],
-        merged: ['merged', merged],
-    })))
-        .with(getWhenMatched(whenNotMatched)).stages;
-};
-const getWhenMatched = (whenNotMatched) => {
-    const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
-    const preMergeOld = mergeObjects(root().of('old').expr(), field({
-        deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
-        touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
-    }));
-    const same = eq(preMergeOld)(root().of('merged').expr());
-    return link().with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
+//#endregion
+//#region .build/lib/aggregate/$merge.js
+const getSubsetMatchForExt = (ext) => {
+	const extObj = mapExactToObject(ext, (v, k) => {
+		return eq(root().of("old").of(k).expr())(val(v));
+	});
+	const checks = Object.values(extObj);
+	return checks.length ? checks.length === 1 ? checks[0] : and(...checks) : null;
+};
+const getWhenMatchedForMerge = (whenNotMatched, update, canWrite) => {
+	const orNull = (e) => whenNotMatched === "discard" ? $ifNull(e, nil) : e;
+	const newOrOld = whenNotMatched === "insert" ? ctx()("new") : root();
+	const merged = mergeObjects(root().expr(), update(ctx()("new").expr(), root().expr()), field({ deletedAt: ["deletedAt", orNull(newOrOld.of("deletedAt").expr())] }));
+	return link().with($replaceWith_(field({
+		old: ["old", root().expr()],
+		merged: ["merged", merged]
+	}))).with(getWhenMatched(whenNotMatched, canWrite)).stages;
+};
+const getWhenMatched = (whenNotMatched, canWrite) => {
+	const orNull = (e) => whenNotMatched === "discard" ? $ifNull(e, nil) : e;
+	const preMergeOld = mergeObjects(root().of("old").expr(), field({
+		deletedAt: ["deletedAt", orNull(root().of("old").of("deletedAt").expr())],
+		touchedAt: ["touchedAt", root().of("merged").of("touchedAt").expr()]
+	}));
+	const diff = ne(preMergeOld)(root().of("merged").expr());
+	const useNew = canWrite ? and(diff, canWrite) : diff;
+	return link().with($replaceWith_(ite(useNew, root().of("merged").expr(), root().of("old").expr()))).stages;
 };
 const $mergeX = (out, keys, f, map, ext, update) => {
-    const patch = mapExact(keys, (v) => {
-        return $ifNull(sub(v, f), nil);
-    });
-    const filter = mapExactToObject(ext, v => ({ $eq: v }));
-    const setDeleted = out.whenNotMatched === 'discard';
-    const replacer = map(field(omitPick().backward(spread(patch, {
-        _id: ['_id', f.of('_id').expr()],
-        touchedAt: ['touchedAt', current],
-    }))));
-    const sss = setDeleted
-        ? link()
-            .with($set_(set()({
-            deletedAt: ['deletedAt', to(current)],
-        })))
-            .with($merge_({
-            into: out.coll,
-            on: root().of('_id'),
-            whenNotMatched: 'insert',
-            stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
-        })).stages
-        : link().with($merge_({
-            into: out.coll,
-            on: root().of('_id'),
-            whenNotMatched: 'fail',
-            stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
-        })).stages;
-    const teardown = (coll) => ({
-        collection: coll,
-        method: 'updateMany',
-        params: [
-            filter,
-            [
-                {
-                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                },
-            ],
-        ],
-    });
-    return {
-        raw: (first) => link().with($replaceWith_(replacer)).with(sss)
-            .stages,
-        teardown: c => c(teardown(out.coll)),
-    };
-};
-const $mergeId = () => (out, keys, id, ext, update = x => x) => {
-    const omRORec = omitRORec();
-    return $mergeX(out, keys, root().of('after'), or => {
-        return ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
-            _id: ['_id', id],
-            touchedAt: ['touchedAt', current],
-        }))), or);
-    }, ext, update);
-};
-const $simpleMergePart = () => (out, keys, ext, update = x => x) => $mergeX(out, keys, root(), id$1, ext, update);
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail', update = x => x) => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {}, update);
-const $mergePart = () => (out, keys, ext, update = x => x) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext, update);
-const $merge = () => (out, keys, update = x => x) => $mergePart()(out, keys, {}, update);
+	const patch = mapExact(keys, (v) => {
+		return $ifNull(sub(v, f), nil);
+	});
+	const filter = mapExactToObject(ext, (v) => ({ $eq: v }));
+	const sameSubset = getSubsetMatchForExt(ext);
+	const setDeleted = out.whenNotMatched === "discard";
+	const replacer = map(field(spread(patch, {
+		_id: ["_id", f.of("_id").expr()],
+		touchedAt: ["touchedAt", current]
+	})));
+	const sss = setDeleted ? link().with($set_(set()({ deletedAt: ["deletedAt", to(current)] }))).with($merge_({
+		into: out.coll,
+		on: root().of("_id"),
+		whenNotMatched: "insert",
+		stages: true,
+		whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update, sameSubset)
+	})).stages : link().with($merge_({
+		into: out.coll,
+		on: root().of("_id"),
+		whenNotMatched: "fail",
+		stages: true,
+		whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update, sameSubset)
+	})).stages;
+	const teardown = (coll) => ({
+		collection: coll,
+		method: "updateMany",
+		params: [filter, [{ $unset: Object.keys(mapExactToObject(keys, () => 1)) }]]
+	});
+	return {
+		raw: (first) => link().with($replaceWith_(replacer)).with(sss).stages,
+		teardown: (c) => c(teardown(out.coll))
+	};
+};
+const $mergeId = () => (out, keys, id, ext, update = (x) => x) => {
+	return $mergeX(out, keys, root().of("after"), (or) => {
+		return ite(eqTyped(root().of("after").expr(), nil), field(spread(mapExact(keys, () => nil), {
+			_id: ["_id", id],
+			touchedAt: ["touchedAt", current]
+		})), or);
+	}, ext, update);
+};
+const $simpleMergePart = () => (out, keys, ext, update = (x) => x) => $mergeX(out, keys, root(), id$1, ext, update);
+const $simpleMerge = () => (out, keys, whenNotMatched = "fail", update = (x) => x) => $mergeX({
+	coll: out,
+	whenNotMatched
+}, keys, root(), id$1, {}, update);
+const $mergePart = () => (out, keys, ext, update = (x) => x) => {
+	return $mergeId()({
+		coll: out,
+		whenNotMatched: "fail"
+	}, keys, assertNotNull$1(root().of("before").of("_id").expr()), ext, update);
+};
+const $merge = () => (out, keys, update = (x) => x) => $mergePart()(out, keys, {}, update);
 const assertNotNull$1 = (expr) => expr;
-
+//#endregion
+//#region .build/lib/aggregate/group/utils/sub-merge.js
 const subMerge = (args, out, gid, extra, idPrefix, first) => {
-    const e = extra;
-    const mergeOldWithNew = mapExact0(args, (v, k) => to(first
-        ? ctx()('new').of(k).expr()
-        : v.merge(root().of('old').of(k).expr(), ctx()('new').of(k).expr())));
-    const mergeAggregates = $set_(set()({
-        merged: ['merged', set()(mergeOldWithNew)],
-    }));
-    const gidPath = root().of(gid).expr();
-    const mapId = (k, v) => map1(k, v);
-    const F1 = {
-        _id: ['_id', to(idPrefix ? concat(val(idPrefix), $rand) : $rand)],
-        touchedAt: ['touchedAt', to(current)],
-    };
-    const F2 = mapId(gid, to(gidPath));
-    const addExtraAndMerge = {
-        ...mapExact0(extra, to),
-        ...F1,
-        ...F2,
-    };
-    const addTSAndExtra = {
-        ...mapExact0(e, to),
-        ...(out.whenNotMatched === 'insert' ? { deletedAt: ['deletedAt', to(nil)] } : {}),
-        touchedAt: ['touchedAt', to(current)],
-    };
-    const updater = set()(addTSAndExtra);
-    const whenMatched = getWhenMatched(out.whenNotMatched);
-    return link()
-        .with($set_(set()(addExtraAndMerge)))
-        .with($merge_({
-        ...out,
-        on: root().of(gid),
-        vars: { new: ['new', root().expr()] },
-        stages: 'ctx',
-        whenMatched: link()
-            .with($replaceWith_(field({ old: ['old', root().expr()], merged: ['merged', root().expr()] })))
-            .with(mergeAggregates)
-            .with($set_(set()({
-            merged: [
-                'merged',
-                subUpdater(updater, root().of('merged')),
-            ],
-        })))
-            .with(whenMatched).stages,
-    })).stages;
+	const e = extra;
+	const mergeOldWithNew = mapExact0(args, (v, k) => to(first ? ctx()("new").of(k).expr() : v.merge(root().of("old").of(k).expr(), ctx()("new").of(k).expr())));
+	const mergeAggregates = $set_(set()({ merged: ["merged", set()(mergeOldWithNew)] }));
+	const gidPath = root().of(gid).expr();
+	const mapId = (k, v) => map1(k, v);
+	const F1 = {
+		_id: ["_id", to(idPrefix ? concat(val(idPrefix), $rand) : $rand)],
+		touchedAt: ["touchedAt", to(current)]
+	};
+	const F2 = mapId(gid, to(gidPath));
+	const extraAndId = spread0(mapExact0(extra, to), F1);
+	const addExtraAndMerge = spread0(extraAndId, F2);
+	const addTSAndExtra = {
+		...mapExact0(e, to),
+		...out.whenNotMatched === "insert" ? { deletedAt: ["deletedAt", to(nil)] } : {},
+		touchedAt: ["touchedAt", to(current)]
+	};
+	const updater = set()(addTSAndExtra);
+	const whenMatched = getWhenMatched(out.whenNotMatched, null);
+	const whenMatchedStages = link().with($replaceWith_(field({
+		old: ["old", root().expr()],
+		merged: ["merged", root().expr()]
+	}))).with(mergeAggregates).with($set_(set()({ merged: ["merged", subUpdater(updater, root().of("merged"))] }))).with(whenMatched).stages;
+	const ready = $set_(set()(addExtraAndMerge));
+	const stages = link().with(ready);
+	if (out.whenNotMatched === "insert") {
+		const insertMarker = $set_(set()({ deletedAt: ["deletedAt", to(nil)] }));
+		return stages.with(insertMarker).with($merge_({
+			into: out.into,
+			whenNotMatched: "insert",
+			on: root().of(gid),
+			vars: { new: ["new", root().expr()] },
+			stages: "ctx",
+			whenMatched: whenMatchedStages
+		})).stages;
+	}
+	if (out.whenNotMatched === "discard") {
+		const discardMarker = $set_(set()({ deletedAt: ["deletedAt", to(current)] }));
+		return stages.with(discardMarker).with($merge_({
+			into: out.into,
+			whenNotMatched: "insert",
+			on: root().of(gid),
+			vars: { new: ["new", root().expr()] },
+			stages: "ctx",
+			whenMatched: whenMatchedStages
+		})).stages;
+	}
+	return stages.with($merge_({
+		into: out.into,
+		whenNotMatched: "fail",
+		on: root().of(gid),
+		vars: { new: ["new", root().expr()] },
+		stages: "ctx",
+		whenMatched: whenMatchedStages
+	})).stages;
 };
-
+//#endregion
+//#region .build/lib/aggregate/group/$group-merge.js
 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 = '') => ({
-    raw: (first) => link()
-        .with(subGroup(id, args, addGrp(gid)))
-        .with(subMerge(args, out, gid, extra, idPrefix, first)).stages,
-    teardown: c => c(out.whenNotMatched === 'insert'
-        ? {
-            collection: out.into,
-            method: 'deleteMany',
-            params: [{}],
-        }
-        : {
-            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);
-
+	return mergeExpr(expr, map1(gid, root().of("_id").expr()));
+};
+const $groupMerge = (id, args, out, gid, extra, idPrefix = "") => ({
+	raw: (first) => link().with(subGroup(id, args, addGrp(gid))).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)
+		}) }, ...out.whenNotMatched === "insert" ? [{ $set: {
+			deletedAt: "$$NOW",
+			touchedAt: "$$CLUSTER_TIME"
+		} }] : []]]
+	})
+});
+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);
+//#endregion
+//#region .build/types/mongo.js
+var mongo_exports = /* @__PURE__ */ __exportAll({});
+__reExport(mongo_exports, require("mongodb"));
+//#endregion
+//#region .build/types/index.js
+var types_exports = /* @__PURE__ */ __exportAll({});
+__reExport(types_exports, mongo_exports);
+//#endregion
+//#region .build/lib/aggregate/set/$replace-with-each.js
 const deltaExpr = (expr) => (field) => {
-    return ite(eqTyped($ifNull(root().of(field).expr(), nil), nil), nil, expr(field));
+	return ite(eqTyped($ifNull(root().of(field).expr(), nil), nil), nil, expr(field));
 };
 const $setEach1 = (updater, dict) => {
-    return $set1(set()(mapExact1(dict, updater)));
+	return $set1(set()(mapExact1(dict, updater)));
 };
 const $setEach = (updater, dict) => $setEach1(updater, dict)(root);
 const $replaceWithEach1 = (t) => {
-    return $setEach(k => to(t(k)), {
-        after: ['after', 'after'],
-        before: ['before', 'before'],
-    });
+	return $setEach((k) => to(t(k)), {
+		after: ["after", "after"],
+		before: ["before", "before"]
+	});
 };
 const $replaceWithEach = (expr) => $replaceWithEach1(deltaExpr(expr));
-
+//#endregion
+//#region .build/lib/aggregate/set/$set-delta.js
 const $replaceWithDelta = (expr) => $replaceWithEach((field) => sub(expr, root().of(field)));
 const $setDelta = (updater) => {
-    const dict = {
-        after1: ['after1', 'after'],
-        before1: ['before1', 'before'],
-    };
-    const side = (k) => root().of(k);
-    const update = (k) => subUpdater(weaken(updater), side(k));
-    return link()
-        .with($setEach(k => to(side(k).expr()), dict))
-        .with($setEach(update, dict))
-        .with($replaceWithEach(field => root().of(`${field}1`).expr()))
-        .with($setEach(k => to(nil), dict)).stages;
+	const dict = {
+		after1: ["after1", "after"],
+		before1: ["before1", "before"]
+	};
+	const side = (k) => root().of(k);
+	const update = (k) => subUpdater(weaken(updater), side(k));
+	return link().with($setEach((k) => to(side(k).expr()), dict)).with($setEach(update, dict)).with($replaceWithEach((field) => root().of(`${field}1`).expr())).with($setEach((k) => to(nil), dict)).stages;
 };
-
+//#endregion
+//#region .build/lib/utils/guard.js
+const sym = (eq) => ({
+	backward: eq.forward,
+	forward: eq.backward,
+	backward1: eq.forward1,
+	forward1: eq.backward1
+});
+const reflex = () => ({
+	backward: id,
+	forward: id,
+	backward1: id,
+	forward1: id
+});
+const id = (x) => x;
+const assertEqual = () => reflex();
+const fromEq = (eq) => ({
+	...eq,
+	backward1: eq.backward,
+	forward1: eq.forward
+});
+const literalsEqaul = (_) => assertEqual();
+//#endregion
+//#region .build/lib/predicate/utils.js
 const operator = () => (op) => (operand) => {
-    return {
-        raw: { [op]: operand },
-    };
+	return { raw: { [op]: operand } };
 };
-
+//#endregion
+//#region .build/lib/predicate/$eq.js
 const dualEq = operator();
-const $eq = dualEq('$eq');
-const $ne = dualEq('$ne');
+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 $type = operator()('$type');
-const $exists = operator()('$exists');
-
-const $expr = (expr) => ({
-    raw: f => ({ $expr: expr.raw(f).get() }),
-});
-
+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 $type = operator()("$type");
+const $exists = operator()("$exists");
+//#endregion
+//#region .build/lib/predicate/$expr.js
+const $expr = (expr) => ({ raw: (f) => safeNarrow()({ $expr: expr.raw(f).get() }) });
+//#endregion
+//#region .build/lib/predicate/$in.js
 const dualIn = operator();
-const $in = dualIn('$in');
-const $nin = dualIn('$nin');
-
+const $in = dualIn("$in");
+const $nin = dualIn("$nin");
+//#endregion
+//#region .build/lib/aggregate/match/$match-delta.js
 const $matchDelta = (query) => concatStages($replaceWithDelta(ite(query, root().expr(), nil)), matchDelta());
 const matchDelta = () => {
-    const part = (side) => root().of(side).expr();
-    return $match_($expr(ne(part('before'))(part('after'))));
+	const part = (side) => root().of(side).expr();
+	return $match_($expr(ne(part("before"))(part("after"))));
 };
-
+//#endregion
+//#region .build/lib/aggregate/match/$match.js
 const $match = (query) => ({
-    raw: $match1($expr(query)),
-    delta: $matchDelta(query),
+	raw: $match1($expr(query)),
+	delta: $matchDelta(query)
 });
-
+//#endregion
+//#region .build/lib/aggregate/unwind/$unwind-delta.js
 const joinIdOf = (k, k1, k1Id, k2Id) => {
-    if (k === k1)
-        return k1Id;
-    if (typeof k === 'string')
-        return k2Id;
-    const idOf = (key) => (key === k1 ? k1Id : k2Id);
-    return concat(idOf(k[0]), val(k[1]), idOf(k[2]));
+	if (k === k1) return k1Id;
+	if (typeof k === "string") return k2Id;
+	const idOf = (key) => key === k1 ? k1Id : k2Id;
+	return concat(idOf(k[0]), val(k[1]), idOf(k[2]));
 };
 const andAlso = (probe, keep) => ite(eqTyped(probe, nil), nil, keep);
 const slotsMany = (k1, k2, k, emptyOf) => {
-    const emptyArr = array();
-    const src = root();
-    const k2Arr = (side) => src.of(side).of(k2).expr();
-    const k2OrEmpty = (side) => $ifNull(k2Arr(side), emptyArr);
-    const k1Id = root().of('_id').expr();
-    const k1Delta = field({
-        before: [
-            'before',
-            $ifNull(src.of('before').of(k1).expr(), nil),
-        ],
-        after: [
-            'after',
-            $ifNull(src.of('after').of(k1).expr(), nil),
-        ],
-        deleted: ['deleted', src.of('deleted').expr()],
-    });
-    const itemId = (k2Id) => {
-        const at = (key) => (key === k1 ? k1Id : k2Id);
-        if (typeof k === 'string')
-            return at(k);
-        return concat(at(k[0]), val(k[1]), at(k[2]));
-    };
-    const keyed = (side) => {
-        const items = ctx()('items').expr();
-        return $let({ items: ['items', k2OrEmpty(side)] }, ite(eq(items)(emptyArr), emptyOf(k1Id), $map0({
-            input: items,
-            as: 'b',
-            expr: field({
-                _id: ['_id', itemId(ctx()('b').of('_id').expr())],
-                value: ['value', ctx()('b').expr()],
-            }),
-        })));
-    };
-    const beforeKeyed = keyed('before');
-    const afterKeyed = keyed('after');
-    const bound = (name) => ctx()(name).expr();
-    const idOf = (name) => ctx()(name).of('_id').expr();
-    const valueOf = (name) => ctx()(name).of('value').expr();
-    const kept = $map0({
-        input: bound('beforeK'),
-        as: 'b',
-        expr: field({
-            _id: ['_id', idOf('b')],
-            before: ['before', valueOf('b')],
-            after: [
-                'after',
-                first$1($map0({
-                    input: filter({
-                        expr: bound('afterK'),
-                        as: 'a',
-                        limit: val(1),
-                        cond: eq(idOf('a'))(idOf('b')),
-                    }),
-                    as: 'a',
-                    expr: valueOf('a'),
-                })),
-            ],
-        }),
-    });
-    const beforeIds = $map0({
-        input: bound('beforeK'),
-        as: 'id',
-        expr: ctx()('id').of('_id').expr(),
-    });
-    const added = $map0({
-        input: filter({
-            expr: bound('afterK'),
-            as: 'a',
-            cond: not(inArray(idOf('a'), beforeIds)),
-        }),
-        as: 'a',
-        expr: field({
-            _id: ['_id', idOf('a')],
-            before: ['before', nil],
-            after: ['after', valueOf('a')],
-        }),
-    });
-    const slots = $let({
-        beforeK: ['beforeK', beforeKeyed],
-        afterK: ['afterK', afterKeyed],
-    }, concatArray(kept, added));
-    const exclude = excludeIdem();
-    return $replaceWith_(field(exclude.backward(mergeExpr(exclude.forward(map1(k2, slots)), map1(k1, k1Delta)))));
+	const emptyArr = array();
+	const src = root();
+	const k2Arr = (side) => src.of(side).of(k2).expr();
+	const k2OrEmpty = (side) => $ifNull(k2Arr(side), emptyArr);
+	const k1Id = root().of("_id").expr();
+	const k1Delta = field({
+		before: ["before", $ifNull(src.of("before").of(k1).expr(), nil)],
+		after: ["after", $ifNull(src.of("after").of(k1).expr(), nil)],
+		deleted: ["deleted", src.of("deleted").expr()]
+	});
+	const itemId = (k2Id) => {
+		const at = (key) => key === k1 ? k1Id : k2Id;
+		if (typeof k === "string") return at(k);
+		return concat(at(k[0]), val(k[1]), at(k[2]));
+	};
+	const keyed = (side) => {
+		const items = ctx()("items").expr();
+		return $let({ items: ["items", k2OrEmpty(side)] }, ite(eq(items)(emptyArr), emptyOf(k1Id), $map0({
+			input: items,
+			as: "b",
+			expr: field({
+				_id: ["_id", itemId(ctx()("b").of("_id").expr())],
+				value: ["value", ctx()("b").expr()]
+			})
+		})));
+	};
+	const beforeKeyed = keyed("before");
+	const afterKeyed = keyed("after");
+	const bound = (name) => ctx()(name).expr();
+	const idOf = (name) => ctx()(name).of("_id").expr();
+	const valueOf = (name) => ctx()(name).of("value").expr();
+	const kept = $map0({
+		input: bound("beforeK"),
+		as: "b",
+		expr: field({
+			_id: ["_id", idOf("b")],
+			before: ["before", valueOf("b")],
+			after: ["after", first($map0({
+				input: filter({
+					expr: bound("afterK"),
+					as: "a",
+					limit: val(1),
+					cond: eq(idOf("a"))(idOf("b"))
+				}),
+				as: "a",
+				expr: valueOf("a")
+			}))]
+		})
+	});
+	const beforeIds = $map0({
+		input: bound("beforeK"),
+		as: "id",
+		expr: ctx()("id").of("_id").expr()
+	});
+	const added = $map0({
+		input: filter({
+			expr: bound("afterK"),
+			as: "a",
+			cond: not(inArray(idOf("a"), beforeIds))
+		}),
+		as: "a",
+		expr: field({
+			_id: ["_id", idOf("a")],
+			before: ["before", nil],
+			after: ["after", valueOf("a")]
+		})
+	});
+	const slots = $let({
+		beforeK: ["beforeK", beforeKeyed],
+		afterK: ["afterK", afterKeyed]
+	}, concatArray(kept, added));
+	return $replaceWith_(field(mergeExpr(map1(k2, slots), map1(k1, k1Delta))));
 };
 const noEmpty = (_id) => array();
 const padEmpty = (id) => array(field({
-    _id: ['_id', id],
-    value: ['value', field({})],
+	_id: ["_id", id],
+	value: ["value", field({})]
 }));
 const joinMany = (k1, k2, eq1, eq2) => {
-    const doc = root();
-    const id = () => root().of(k2).of('_id').expr();
-    const k1At = (side) => doc.of(k1).of(side).expr();
-    const rowOf = (a, b) => mergeObjects(mergeObjects(field({ _id: ['_id', id()] }), field(map1(k1, a))), field(map1(k2, b)));
-    const rowPad = (k1v, n2) => {
-        return rowOf(k1v, n2.forward(nil));
-    };
-    const rowReal = (k1v, k2v) => rowOf(k1v, k2v);
-    const k2join = (raw, orNull, pad, real) => ite(eqTyped(raw, field({})), pad, andAlso(orNull, real));
-    const joinAt = (side) => {
-        const k2t = () => root().of(k2).of(side).expr();
-        const k2w = () => root().of(k2).of(side).expr();
-        if (!eq1) {
-            const k1t = () => root().of(k1).of(side).expr();
-            return andAlso(k1At(side), k2join(k2t(), k2t(), eq2 ? rowPad(k1t(), eq2) : nil, rowReal(k1t(), k2t())));
-        }
-        const k1v = () => {
-            return $ifNull(root().of(k1).of(side).expr(), eq1.forward(nil));
-        };
-        return k2join(k2w(), k2w(), eq2 ? rowPad(k1v(), eq2) : nil, rowReal(k1v(), k2w()));
-    };
-    const isPad = (side) => ite(eq(doc.of(k2).of(side).expr())(field({})), val(true), doc.of(k1).of('deleted').of(side).expr());
-    const joinDelta = field({
-        _id: ['_id', id()],
-        before: ['before', joinAt('before')],
-        after: ['after', joinAt('after')],
-        deleted: [
-            'deleted',
-            field({
-                before: ['before', isPad('before')],
-                after: ['after', isPad('after')],
-            }),
-        ],
-    });
-    return $replaceWith_(joinDelta);
+	const doc = root();
+	const id = () => root().of(k2).of("_id").expr();
+	const k1At = (side) => doc.of(k1).of(side).expr();
+	const rowOf = (a, b) => mergeObjects(mergeObjects(field({ _id: ["_id", id()] }), field(map1(k1, a))), field(map1(k2, b)));
+	const rowPad = (k1v, n2) => {
+		return rowOf(k1v, n2.forward(nil));
+	};
+	const rowReal = (k1v, k2v) => rowOf(k1v, k2v);
+	const k2join = (raw, orNull, pad, real) => ite(eqTyped(raw, field({})), pad, andAlso(orNull, real));
+	const joinAt = (side) => {
+		const k2t = () => root().of(k2).of(side).expr();
+		const k2w = () => root().of(k2).of(side).expr();
+		if (!eq1) {
+			const k1t = () => root().of(k1).of(side).expr();
+			return andAlso(k1At(side), k2join(k2t(), k2t(), eq2 ? rowPad(k1t(), eq2) : nil, rowReal(k1t(), k2t())));
+		}
+		const k1v = () => {
+			return $ifNull(root().of(k1).of(side).expr(), eq1.forward(nil));
+		};
+		return k2join(k2w(), k2w(), eq2 ? rowPad(k1v(), eq2) : nil, rowReal(k1v(), k2w()));
+	};
+	const isPad = (side) => ite(eq(doc.of(k2).of(side).expr())(field({})), val(true), doc.of(k1).of("deleted").of(side).expr());
+	const joinDelta = field({
+		_id: ["_id", id()],
+		before: ["before", joinAt("before")],
+		after: ["after", joinAt("after")],
+		deleted: ["deleted", field({
+			before: ["before", isPad("before")],
+			after: ["after", isPad("after")]
+		})]
+	});
+	return $replaceWith_(joinDelta);
 };
 const $unwindDelta = (k1, k2, k, includeNull1, includeNull2) => {
-    const stages = (emptyOf, eq1, eq2) => {
-        return link()
-            .with(slotsMany(k1, k2, k, emptyOf))
-            .with($unwind_(k2))
-            .with(joinMany(k1, k2, eq1, eq2))
-            .with(matchDelta()).stages;
-    };
-    const run = (emptyOf) => stages(emptyOf, includeNull1 === null && literalsEqaul(), includeNull2 === null && literalsEqaul());
-    if (k === k2)
-        return run(noEmpty);
-    if (includeNull2 === null)
-        return run(padEmpty);
-    return run(noEmpty);
+	const stages = (emptyOf, eq1, eq2) => {
+		return link().with(slotsMany(k1, k2, k, emptyOf)).with($unwind_(k2)).with(joinMany(k1, k2, eq1, eq2)).with(matchDelta()).stages;
+	};
+	const run = (emptyOf) => stages(emptyOf, includeNull1 === null && literalsEqaul(includeNull1), includeNull2 === null && literalsEqaul(includeNull2));
+	if (k === k2) return run(noEmpty);
+	if (includeNull2 === null) return run(padEmpty);
+	return run(noEmpty);
 };
-
-const $unwind = (k, dict, middle = '.') => {
-    const joinK = ['left', middle, 'right'];
-    return {
-        delta: link()
-            .with($replaceWithDelta(field({
-            _id: ['_id', root().of('_id').expr()],
-            left: ['left', root().expr()],
-            right: ['right', root().of(k).expr()],
-        })))
-            .with($unwindDelta('left', 'right', joinK))
-            .with($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
-            key: root().of('right').expr(),
-            id: root().of('_id').expr(),
-        }, dict)))).stages,
-        raw: (f) => link()
-            .with($unwind1(k)(f))
-            .with($set1(set()({
-            _id: [
-                '_id',
-                to(joinIdOf(joinK, 'left', root().of('_id').expr(), root().of(k).of('_id').expr())),
-            ],
-        }))(f)).stages,
-    };
+//#endregion
+//#region .build/lib/aggregate/unwind/index.js
+const $unwind = (k, dict, middle = ".") => {
+	const joinK = [
+		"left",
+		middle,
+		"right"
+	];
+	return {
+		delta: link().with($replaceWithDelta(field({
+			_id: ["_id", root().of("_id").expr()],
+			left: ["left", root().expr()],
+			right: ["right", root().of(k).expr()]
+		}))).with($unwindDelta("left", "right", joinK)).with($replaceWithDelta(mergeObjects(root().of("left").expr(), fieldM({
+			key: root().of("right").expr(),
+			id: root().of("_id").expr()
+		}, dict)))).stages,
+		raw: (f) => link().with($unwind1(k)(f)).with($set1(set()({ _id: ["_id", to(joinIdOf(joinK, "left", root().of("_id").expr(), root().of(k).of("_id").expr()))] }))(f)).stages
+	};
 };
-
+//#endregion
+//#region .build/lib/aggregate/lookup/$lookup-delta.js
 const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, includeNull1, includeNull2) => {
-    const omit = omitRORec();
-    const hash = crypto$1
-        .createHash('md5')
-        .update(coll.collectionName + jsonCanonicalize.canonicalize(input) + jsonCanonicalize.canonicalize(exec))
-        .digest('base64url');
-    const normForeignKey = (f) => to($ifNull(root().of(f).of(k1).with(field1).expr(), val(hash)));
-    return link()
-        .with($replaceWithDelta(field(map1(k1, root().expr()))))
-        .with($set_(set()({
-        bId: ['bId', normForeignKey('before')],
-        aId: ['aId', normForeignKey('after')],
-    })))
-        .with($simpleLookup_({
-        coll,
-        k: 'a',
-        fields: {
-            foreign: root().of('before').with(field2),
-            local: root().of('aId'),
-        },
-        vars: {},
-        pipeline: link().with(input).with(exec).stages,
-    }))
-        .with($simpleLookup_({
-        coll,
-        k: 'b',
-        fields: {
-            foreign: root().of('before').with(field2),
-            local: root().of('bId'),
-        },
-        vars: {},
-        pipeline: link().with(input).with(exec).stages,
-    }))
-        .with($replaceWithEach((f) => {
-        const joined = (side, arr) => {
-            const here = root();
-            return ite(eqTyped(root().of(side).expr(), nil), nil, field(omit.backward(mergeExpr(omit.forward(map1(k2, here.of(arr).of('before').expr())), map1(k1, here
-                .of(side)
-                .of(k1)
-                .expr())))));
-        };
-        return f === 'after' ? joined('after', 'a') : joined('before', 'b');
-    }))
-        .with(includeNull1 === null
-        ? $replaceWithEach1((part) => {
-            const otherPart = root().of(part === 'after' ? 'before' : 'after');
-            const n1 = literalsEqaul().forward(nil);
-            const expr = $ifNull(root().of(part).expr(), field(omit.backward(mergeExpr(omit.forward(map1(k2, otherPart.of(k2).expr())), map1(k1, n1)))));
-            return expr;
-        })
-        : link().stages)
-        .with($unwindDelta(k1, k2, k, includeNull1, includeNull2)).stages;
+	const hash = crypto$1.default.createHash("md5").update(coll.collectionName + (0, json_canonicalize.canonicalize)(input) + (0, json_canonicalize.canonicalize)(exec)).digest("base64url");
+	const normForeignKey = (f) => to($ifNull(root().of(f).of(k1).with(field1).expr(), asExpr(val(hash))));
+	return link().with($replaceWithDelta(field(map1(k1, root().expr())))).with($set_(set()({
+		bId: ["bId", normForeignKey("before")],
+		aId: ["aId", normForeignKey("after")]
+	}))).with($simpleLookup_({
+		coll,
+		k: "a",
+		fields: {
+			foreign: root().of("before").with(field2),
+			local: root().of("aId")
+		},
+		vars: {},
+		pipeline: link().with(input).with(exec).stages
+	})).with($simpleLookup_({
+		coll,
+		k: "b",
+		fields: {
+			foreign: root().of("before").with(field2),
+			local: root().of("bId")
+		},
+		vars: {},
+		pipeline: link().with(input).with(exec).stages
+	})).with($replaceWithEach((f) => {
+		const joined = (side, arr) => {
+			const here = root();
+			return ite(eqTyped(root().of(side).expr(), nil), nil, field(mergeExpr(map1(k2, here.of(arr).of("before").expr()), map1(k1, here.of(side).of(k1).expr()))));
+		};
+		return f === "after" ? joined("after", "a") : joined("before", "b");
+	})).with(includeNull1 === null ? $replaceWithEach1((part) => {
+		const otherPart = root().of(part === "after" ? "before" : "after");
+		const n1 = literalsEqaul(includeNull1).forward(nil);
+		return $ifNull(root().of(part).expr(), field(mergeExpr(map1(k2, otherPart.of(k2).expr()), map1(k1, n1))));
+	}) : link().stages).with($unwindDelta(k1, k2, k, includeNull1, includeNull2)).stages;
 };
-
+//#endregion
+//#region .build/lib/aggregate/lookup/$lookup-raw.js
 const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNull) => (f) => {
-    const left = root().of('_id').expr();
-    const right = root().of(k2).of('_id').expr();
-    const keepLeft = k === 'left';
-    const composedId = typeof k === 'string' ? right : concat(left, val(k[1]), right);
-    return link()
-        .with($simpleLookup1({
-        coll,
-        k: k2,
-        fields: {
-            local: field1,
-            foreign: root().of('before').with(field2),
-        },
-        vars: {},
-        pipeline: link()
-            .with(input)
-            .with(exec)
-            .with($replaceWith_(root().of('before').expr())).stages,
-    })(f))
-        .with($unwind1(k2, includeNull)(f))
-        .with(keepLeft
-        ? link().stages
-        : $set1(set()({
-            _id: ['_id', to($ifNull(composedId, left))],
-        }))(f)).stages;
+	const left = root().of("_id").expr();
+	const right = root().of(k2).of("_id").expr();
+	const keepLeft = k === "left";
+	const composedId = typeof k === "string" ? right : concat(left, val(k[1]), right);
+	return link().with($simpleLookup1({
+		coll,
+		k: k2,
+		fields: {
+			local: field1,
+			foreign: root().of("before").with(field2)
+		},
+		vars: {},
+		pipeline: link().with(input).with(exec).with($replaceWith_(root().of("before").expr())).stages
+	})(f)).with($unwind1(k2, includeNull)(f)).with(keepLeft ? link().stages : $set1(set()({ _id: ["_id", to($ifNull(composedId, left))] }))(f)).stages;
 };
-
-const asBefore = (f) => f(() => root().of('before'));
-
+//#endregion
+//#region .build/lib/utils/before.js
+const asBefore = (f) => f(() => root().of("before"));
+//#endregion
+//#region .build/lib/utils/log.js
 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 indexMap = new Map();
+const log = (...args) => console.log(/* @__PURE__ */ new Date(), ...args.map((a) => typeof a === "function" ? a(replace) : a && typeof a === "object" ? json(a) : a));
+//#endregion
+//#region .build/lib/utils/db-indexes.js
+const indexMap = /* @__PURE__ */ new Map();
 const createIndex = async (collection, indexSpec, op) => {
-    const { name, ...options } = op ?? {};
-    const map = indexMap.get(collection.collectionName) ?? new Map();
-    indexMap.set(collection.collectionName, map);
-    const indexKey = `${JSON.stringify(indexSpec)}-${JSON.stringify(options)}`;
-    if (map.has(indexKey)) {
-        await map.get(indexKey);
-        return;
-    }
-    const promise = createIndexWithRetry(collection, indexSpec, op);
-    map.set(indexKey, promise);
-    await promise;
+	const { name, ...options } = op ?? {};
+	const map = indexMap.get(collection.collectionName) ?? /* @__PURE__ */ new Map();
+	indexMap.set(collection.collectionName, map);
+	const indexKey = `${JSON.stringify(indexSpec)}-${JSON.stringify(options)}`;
+	if (map.has(indexKey)) {
+		await map.get(indexKey);
+		return;
+	}
+	const promise = createIndexWithRetry(collection, indexSpec, op);
+	map.set(indexKey, promise);
+	await promise;
 };
 const createIndexWithRetry = async (collection, indexSpec, options) => {
-    const log = () => { };
-    log('Creating index', { collection: collection.collectionName});
-    while (true) {
-        try {
-            await collection.createIndex(indexSpec, options);
-            log('Index created', { collection: collection.collectionName, indexSpec, options });
-        }
-        catch (e) {
-            if ([85, 276].includes(e.code)) {
-                log('Index created with different name', e.code, {
-                    collection: collection.collectionName});
-                break;
-            }
-            if (e.code == 12587) {
-                await new Promise(res => setTimeout(res, 300));
-                continue;
-            }
-            log('Error creating index', {
-                collection: collection.collectionName});
-            console.error('Error creating index', e);
-            throw e;
-        }
-        break;
-    }
+	collection.collectionName;
+	while (true) {
+		try {
+			await collection.createIndex(indexSpec, options);
+			collection.collectionName;
+		} catch (e) {
+			if ([85, 276].includes(e.code)) {
+				e.code, collection.collectionName;
+				break;
+			}
+			if (e.code == 12587) {
+				await new Promise((res) => setTimeout(res, 300));
+				continue;
+			}
+			collection.collectionName;
+			console.error("Error creating index", e);
+			throw e;
+		}
+		break;
+	}
 };
 const ensureCollection = async (db, collectionName) => {
-    if (!(await db.listCollections({ name: collectionName }, { nameOnly: true }).next())) {
-        await db.createCollection(collectionName);
-    }
+	if (!await db.listCollections({ name: collectionName }, { nameOnly: true }).next()) await db.createCollection(collectionName);
 };
-
+//#endregion
+//#region .build/lib/utils/merge/utils.js
 const patch = ({ ...x }, k, v) => {
-    delete x[k];
-    return { ...x, [k]: v };
+	delete x[k];
+	return {
+		...x,
+		[k]: v
+	};
 };
 const restart = (sources) => {
-    return map(sources, x => x.stop());
+	return map(sources, (x) => x.stop());
 };
 const race = (sources) => {
-    const promises = Object.values(map(sources, ({ next }, key) => next.then(frame => ({ key, frame }), error => new Error(error))));
-    return Promise.any(promises).then((result) => {
-        if (result instanceof Error) {
-            throw result;
-        }
-        else {
-            return result;
-        }
-    });
+	const promises = Object.values(map(sources, ({ next }, key) => next.then((frame) => ({
+		key,
+		frame
+	}), (error) => new Error(error))));
+	return Promise.any(promises).then((result) => {
+		if (result instanceof Error) throw result;
+		else return result;
+	});
 };
-
+//#endregion
+//#region .build/lib/utils/merge/next-winner.js
 const nextWinner = (previousWinner, previousWinnerNextFrame, sources, interrupt) => {
-    const { frame: previousFrame, key } = previousWinner;
-    if (!interrupt?.(key) && previousFrame.info.job) {
-        return previousWinnerNextFrame.then((previousFrameSuccessor) => {
-            if (previousFrameSuccessor.info.job) {
-                return { frame: previousFrameSuccessor, key };
-            }
-            return race(sources);
-        });
-    }
-    return race(sources);
+	const { frame: previousFrame, key } = previousWinner;
+	if (!interrupt?.(key) && previousFrame.info.job) return previousWinnerNextFrame.then((previousFrameSuccessor) => {
+		if (previousFrameSuccessor.info.job) return {
+			frame: previousFrameSuccessor,
+			key
+		};
+		return race(sources);
+	});
+	return race(sources);
 };
-
-const makeSelect = (winner, nextFrame, interrupt) => sources => nextWinner(winner, nextFrame, sources, interrupt);
+//#endregion
+//#region .build/lib/utils/merge/merge.js
+const makeSelect = (winner, nextFrame, interrupt) => (sources) => nextWinner(winner, nextFrame, sources, interrupt);
 const makeContinuation = (sources, winner, interrupt, hooks) => () => {
-    const { frame, key } = winner;
-    const result = frame.cont();
-    hooks?.start?.(frame, result);
-    return mergeIterators({
-        sources: patch(sources, key, result),
-        interrupt,
-        select: makeSelect(winner, result.next, interrupt),
-        hooks,
-    });
+	const { frame, key } = winner;
+	const result = frame.cont();
+	hooks?.start?.(frame, result);
+	return mergeIterators({
+		sources: patch(sources, key, result),
+		interrupt,
+		select: makeSelect(winner, result.next, interrupt),
+		hooks
+	});
 };
 const makeReiterate = (sources, interrupt, hooks) => (winner) => {
-    const { frame, key } = winner;
-    return {
-        cont: makeContinuation(sources, winner, interrupt, hooks),
-        data: frame.data,
-        info: { key, value: frame.info, job: frame.info.job },
-    };
+	const { frame, key } = winner;
+	return {
+		cont: makeContinuation(sources, winner, interrupt, hooks),
+		data: frame.data,
+		info: {
+			key,
+			value: frame.info,
+			job: frame.info.job
+		}
+	};
 };
 const mergeIterators = (params) => {
-    const { sources, interrupt, select = race, hooks } = params;
-    return {
-        stop: () => mergeIterators({ sources: restart(sources), interrupt, select, hooks }),
-        next: select(sources).then(makeReiterate(sources, interrupt, hooks)),
-        clear: async () => {
-            for (const key in sources) {
-                await sources[key].clear();
-            }
-        },
-    };
+	const { sources, interrupt, select = race, hooks } = params;
+	return {
+		stop: () => mergeIterators({
+			sources: restart(sources),
+			interrupt,
+			select,
+			hooks
+		}),
+		next: select(sources).then(makeReiterate(sources, interrupt, hooks)),
+		clear: async () => {
+			for (const key in sources) await sources[key].clear();
+		}
+	};
 };
-
+//#endregion
+//#region .build/lib/utils/merge/combiners.js
 const state = { steady: false };
 let timeout = null;
 const firstWorksMerge = (iters) => {
-    const iterator = () => {
-        const results = iters.map(iter => iter());
-        const sources = { ...results };
-        return mergeIterators({
-            sources,
-            interrupt: key => false,
-            hooks: {
-                start: (frame, result) => {
-                    if (!frame.info.job)
-                        return;
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                        timeout = null;
-                    }
-                    result.next.then(() => {
-                        if (!frame.info.job)
-                            return;
-                        if (!state.steady) {
-                            if (timeout !== null)
-                                clearTimeout(timeout);
-                            timeout = setTimeout(() => {
-                                state.steady = true;
-                                console.log('steady');
-                            }, 2000);
-                        }
-                    });
-                },
-            },
-        });
-    };
-    return iterator;
+	const iterator = () => {
+		const results = iters.map((iter) => iter());
+		const sources = Object.fromEntries(results.map((result, index) => [String(index), result]));
+		return mergeIterators({
+			sources,
+			interrupt: (key) => false,
+			hooks: { start: (frame, result) => {
+				if (!frame.info.job) return;
+				if (timeout !== null) {
+					clearTimeout(timeout);
+					timeout = null;
+				}
+				result.next.then(() => {
+					if (!frame.info.job) return;
+					if (!state.steady) {
+						if (timeout !== null) clearTimeout(timeout);
+						timeout = setTimeout(() => {
+							state.steady = true;
+							console.log("steady");
+						}, 2e3);
+					}
+				});
+			} }
+		});
+	};
+	return iterator;
+};
+//#endregion
+//#region .build/lib/machine.js
+var Machine = class {
+	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);
+	}
 };
-
-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) => root;
 const runCont = async (it, cb) => {
-    while (true) {
-        const { next, stop: _, clear } = it();
-        const res = await next.then(next => ({ ok: true, next }), err => ({ ok: false, err }));
-        if (!res.ok) {
-            console.error(res.err);
-            process.exit(1);
-        }
-        const { cont, info } = res.next;
-        if (cb?.(info)) {
-            await clear();
-            throw new Error('Machine stopped');
-        }
-        it = cont;
-    }
+	while (true) {
+		const { next, stop: _, clear } = it();
+		const res = await next.then((next) => ({
+			ok: true,
+			next
+		}), (err) => ({
+			ok: false,
+			err
+		}));
+		if (!res.ok) {
+			console.error(res.err);
+			process.exit(1);
+		}
+		const { cont, info } = res.next;
+		if (cb?.(info)) {
+			await clear();
+			throw new Error("Machine stopped");
+		}
+		it = cont;
+	}
 };
-
-const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
+//#endregion
+//#region .build/lib/aggregate/lookup/index.js
+const merge = ({ lsource: L, rsource: R }) => mergeIterators({ sources: {
+	L,
+	R
+} });
 const join = (params, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
-    const { lField, rField, left, right, as } = params;
-    const rightJoinField = { field1: lField, field2: rField };
-    const joinId = params.to === 'one' ? 'left' : ['left', params.middle, 'right'];
-    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
-    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, outerLeft);
-            const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, undefined, outerLeft);
-            const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
-                a: root().of('right').expr(),
-                b: root().of('_id').expr(),
-            }, dictId))), stagesUntilNextLookup.delta);
-            const lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
-            const rRunnerInput = concatStages(joinL_Delta, mergeForeignIntoDoc);
-            const getRunner = (f, stages, final) => f.out({
-                raw: first => concatStages(stages, final.raw(first)),
-                teardown: final.teardown,
-            }, async () => {
-                log('Creating indexes for lookup left', leftSnapshot.coll.collectionName, {
-                    [`before.${lField.str()}`]: 1,
-                });
-                await createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }, { name: 'left_' + new mongodb.UUID().toString('base64') });
-                log('Creating indexes for lookup right', rightSnapshot.coll.collectionName, {
-                    [`before.${rField.str()}`]: 1,
-                });
-                await createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }, { name: 'right_' + new mongodb.UUID().toString('base64') });
-            });
-            const lRunner = getRunner(left, lRunnerInput, finalInput);
-            const rRunner = getRunner(right, rRunnerInput, finalInput);
-            return () => merge({ lsource: lRunner(), rsource: rRunner() });
-        },
-    };
+	const { lField, rField, left, right, as } = params;
+	const rightJoinField = {
+		field1: lField,
+		field2: rField
+	};
+	const joinId = params.to === "one" ? "left" : [
+		"left",
+		params.middle,
+		"right"
+	];
+	const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
+	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 joinL_Delta = $lookupDelta({
+				field1: rField,
+				field2: lField
+			}, leftSnapshot, "right", "left", joinId, outerLeft);
+			const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, "left", "right", joinId, void 0, outerLeft);
+			const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of("left").expr(), fieldM({
+				a: root().of("right").expr(),
+				b: root().of("_id").expr()
+			}, dictId))), stagesUntilNextLookup.delta);
+			const lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
+			const rRunnerInput = concatStages(joinL_Delta, mergeForeignIntoDoc);
+			const getRunner = (f, stages, final) => f.out({
+				raw: (first) => concatStages(stages, final.raw(first)),
+				teardown: final.teardown
+			}, async () => {
+				log("Creating indexes for lookup left", leftSnapshot.coll.collectionName, { [`before.${lField.str()}`]: 1 });
+				await createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }, { name: "left_" + new types_exports.UUID().toString("base64") });
+				log("Creating indexes for lookup right", rightSnapshot.coll.collectionName, { [`before.${rField.str()}`]: 1 });
+				await createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }, { name: "right_" + new types_exports.UUID().toString("base64") });
+			});
+			const lRunner = getRunner(left, lRunnerInput, finalInput);
+			const rRunner = getRunner(right, rRunnerInput, finalInput);
+			return () => merge({
+				lsource: lRunner(),
+				rsource: rRunner()
+			});
+		}
+	};
 };
 const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
-const $lookup = (p) => (l) => p.to === 'one'
-    ? $lookup1({
-        right: p.from,
-        as: p.as,
-        lField: p.localField,
-        rField: root().of('_id'),
-        left: l(emptyDelta()),
-        to: 'one',
-    })
-    : $lookup1({
-        to: 'many',
-        right: p.from,
-        as: p.as,
-        lField: p.localField,
-        rField: p.foreignField,
-        left: l(emptyDelta()),
-        middle: p.middle,
-    });
-const $outerLookup = (p) => (l) => p.to === 'one'
-    ? $lookup1({
-        right: p.from,
-        as: p.as,
-        lField: p.localField,
-        rField: root().of('_id'),
-        left: l(emptyDelta()),
-        to: 'one',
-    }, null)
-    : $lookup1({
-        to: 'many',
-        right: p.from,
-        as: p.as,
-        lField: p.localField,
-        rField: p.foreignField,
-        left: l(emptyDelta()),
-        middle: p.middle,
-    }, null);
-
+const $lookup = (p) => (l) => p.to === "one" ? $lookup1({
+	right: p.from,
+	as: p.as,
+	lField: p.localField,
+	rField: root().of("_id"),
+	left: l(emptyDelta()),
+	to: "one"
+}) : $lookup1({
+	to: "many",
+	right: p.from,
+	as: p.as,
+	lField: p.localField,
+	rField: p.foreignField,
+	left: l(emptyDelta()),
+	middle: p.middle
+});
+const $outerLookup = (p) => (l) => p.to === "one" ? $lookup1({
+	right: p.from,
+	as: p.as,
+	lField: p.localField,
+	rField: root().of("_id"),
+	left: l(emptyDelta()),
+	to: "one"
+}, null) : $lookup1({
+	to: "many",
+	right: p.from,
+	as: p.as,
+	lField: p.localField,
+	rField: p.foreignField,
+	left: l(emptyDelta()),
+	middle: p.middle
+}, null);
+//#endregion
+//#region .build/lib/aggregate/set/$set.js
 const $setCore = (updater) => ({
-    delta: $setDelta(updater),
-    raw: $set1(updater),
-    lin: $set_(updater),
+	delta: $setDelta(updater),
+	raw: $set1(updater),
+	lin: $set_(updater)
 });
 const $set = () => (fields) => $setCore(setQ()(fields));
 const $replaceWith = (expr) => ({
-    delta: $replaceWithDelta(expr),
-    raw: $replaceWith1(expr),
-    lin: $replaceWith_(expr),
-});
-
-const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
-    const filter = mapExactToObject(ext, v => ({ $eq: v }));
-    return {
-        teardown: c => c({
-            collection: out,
-            method: 'updateMany',
-            params: [
-                filter,
-                [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }],
-            ],
-        }),
-        raw: () => {
-            const replacer = map(mergeObjects(expr, field(mergeExpr(extExpr, {
-                deletedAt: ['deletedAt', nil],
-                touchedAt: ['touchedAt', current],
-            }))));
-            return link()
-                .with($replaceWith_(replacer))
-                .with($merge_({
-                into: out,
-                on: root().of('_id'),
-                stages: true,
-                whenMatched: getWhenMatchedForMerge('insert', update),
-                whenNotMatched: 'insert',
-            })).stages;
-        },
-    };
+	delta: $replaceWithDelta(expr),
+	raw: $replaceWith1(expr),
+	lin: $replaceWith_(expr)
+});
+//#endregion
+//#region .build/lib/aggregate/$upsert.js
+const $insertX = (out, expr, map, ext, extExpr, update = (x) => x) => {
+	const filter = mapExactToObject(ext, (v) => ({ $eq: v }));
+	const sameSubset = getSubsetMatchForExt(ext);
+	return {
+		teardown: (c) => c({
+			collection: out,
+			method: "updateMany",
+			params: [filter, [{ $set: {
+				deletedAt: "$$NOW",
+				touchedAt: "$$CLUSTER_TIME"
+			} }]]
+		}),
+		raw: () => {
+			const replacer = map(mergeObjects(expr, field(mergeExpr(extExpr, {
+				deletedAt: ["deletedAt", nil],
+				touchedAt: ["touchedAt", current]
+			}))));
+			return link().with($replaceWith_(replacer)).with($merge_({
+				into: out,
+				on: root().of("_id"),
+				stages: true,
+				whenMatched: getWhenMatchedForMerge("insert", update, sameSubset),
+				whenNotMatched: "insert"
+			})).stages;
+		}
+	};
 };
 const $simpleInsert = (out, ext) => {
-    const extExpr = mapExact(ext, (v) => val(v));
-    return $insertX(out, root().expr(), id$1, ext, extExpr);
+	const extExpr = mapExact(ext, (v) => val(v));
+	return $insertX(out, root().expr(), id$1, ext, extExpr);
 };
 const $insertPart = (out, ext) => {
-    const extExpr = mapExact(ext, (v) => val(v));
-    return $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field(mergeExpr(translateOmit().forward(extExpr), {
-        deletedAt: ['deletedAt', current],
-        _id: [
-            '_id',
-            assertNotNull(root().of('before').of('_id').expr()),
-        ],
-        touchedAt: ['touchedAt', current],
-    })), x), ext, extExpr);
+	const extExpr = mapExact(ext, (v) => val(v));
+	return $insertX(out, assertNotNull(root().of("after").expr()), (x) => ite(eq(root().of("after").expr())(nil), field(mergeExpr(extExpr, {
+		deletedAt: ["deletedAt", current],
+		_id: ["_id", assertNotNull(root().of("before").of("_id").expr())],
+		touchedAt: ["touchedAt", current]
+	})), x), ext, extExpr);
 };
 const $insert = (out) => $insertPart(out, {});
 const assertNotNull = (expr) => expr;
-
+//#endregion
+//#region .build/lib/stream/aggregate.js
 const aggregate = (db, streamName, input, snapshot = true, start = Date.now()) => input(({ coll, input }) => {
-    const req = {
-        aggregate: coll.collectionName,
-        pipeline: input,
-        cursor: {},
-        ...(snapshot && { readConcern: { level: 'snapshot' } }),
-    };
-    log('exec', streamName, req);
-    const start2 = Date.now();
-    return db.command(req)
-        .then(result => {
-        log('prepare', streamName, Date.now() - start);
-        log('prepare2', streamName, start2 - start);
-        const r = result;
-        log('execed', streamName, (replace) => replace(JSON.stringify(req).replaceAll('"$$CLUSTER_TIME"', JSON.stringify(r.cursor.atClusterTime))), result, 'took', Date.now() - start);
-        return r;
-    }, async (err) => {
-        log('err', req, err);
-        console.error(err);
-        await new Promise(() => { });
-        throw new Error(err);
-    });
-});
-
+	const req = {
+		aggregate: coll.collectionName,
+		pipeline: input,
+		cursor: {},
+		...snapshot && { readConcern: { level: "snapshot" } }
+	};
+	log("exec", streamName, req);
+	const start2 = Date.now();
+	return db.command(req).then((result) => {
+		log("prepare", streamName, Date.now() - start);
+		log("prepare2", streamName, start2 - start);
+		const r = result;
+		log("execed", streamName, (replace) => replace(JSON.stringify(req).replaceAll("\"$$CLUSTER_TIME\"", JSON.stringify(r.cursor.atClusterTime))), result, "took", Date.now() - start);
+		return r;
+	}, async (err) => {
+		log("err", req, err);
+		console.error(err);
+		await new Promise(() => {});
+		throw new Error(err);
+	});
+});
+//#endregion
+//#region .build/lib/utils/tear-down.js
 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 () => {
-                await tr();
-                await clear();
-            },
-        };
-    };
+	if (!tr) return it;
+	return () => {
+		const { next, stop, clear } = it();
+		return {
+			next: next.then(({ cont, ...res }) => ({
+				cont: addTeardown(cont, tr),
+				...res
+			})),
+			stop: () => (tr(), stop()),
+			clear: async () => {
+				await tr();
+				await clear();
+			}
+		};
+	};
 };
-
-const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-const maxTimestamp = new mongodb.Timestamp(0xffffffffffffffffn);
+//#endregion
+//#region .build/lib/watch.js
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const maxTimestamp = new mongodb.Timestamp(18446744073709551615n);
 const getCurrentTimestamp = async (db) => {
-    const adminDb = db.admin();
-    const serverStatus = await adminDb.command({ serverStatus: 1 });
-    return serverStatus['operationTime'];
+	return (await db.admin().command({ serverStatus: 1 }))["operationTime"];
 };
 async function getLastCommittedTs(adminDb) {
-    const st = await adminDb.command({ replSetGetStatus: 1 });
-    return st?.optimes?.lastCommittedOpTime?.ts ?? null;
+	return (await adminDb.command({ replSetGetStatus: 1 }))?.optimes?.lastCommittedOpTime?.ts ?? null;
 }
-async function waitUntilStablePast(db, oplogTs, { pollMs = 0, timeoutMs = 10_000 } = {}) {
-    const adminDb = db.client.db('admin');
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-        const stable = await getLastCommittedTs(adminDb);
-        if (stable && stable.comp(oplogTs) >= 0)
-            return;
-        if (Date.now() > deadline) {
-            throw new Error('Timed out waiting for stable timestamp to reach oplog event time');
-        }
-        await sleep(pollMs);
-    }
+async function waitUntilStablePast(db, oplogTs, { pollMs = 0, timeoutMs = 1e4 } = {}) {
+	const adminDb = db.client.db("admin");
+	const deadline = Date.now() + timeoutMs;
+	while (true) {
+		const stable = await getLastCommittedTs(adminDb);
+		if (stable && stable.comp(oplogTs) >= 0) return;
+		if (Date.now() > deadline) throw new Error("Timed out waiting for stable timestamp to reach oplog event time");
+		await sleep(pollMs);
+	}
 }
 async function* tailOplog(db) {
-    let lastTs = await getCurrentTimestamp(db);
-    const reopenDelayMs = 250;
-    const coll = db.client.db('local').collection('oplog.rs');
-    while (true) {
-        const cursor = coll.find({
-            ts: { $gt: lastTs },
-            $or: [
-                {
-                    ns: RegExp(`^${db.namespace}\\.(?!tmp_)(?!__).*(?<!_snapshot)$`),
-                    op: { $in: ['i', 'u'] },
-                },
-                {
-                    ns: 'admin.$cmd',
-                    op: 'c',
-                    'o.applyOps': {
-                        $elemMatch: {
-                            ns: RegExp(`^${db.namespace}\\.(?!tmp_)(?!__).*(?<!_snapshot)$`),
-                            op: { $in: ['i', 'u'] },
-                        },
-                    },
-                },
-            ],
-        }, {
-            tailable: true,
-            awaitData: true,
-            noCursorTimeout: true,
-        });
-        try {
-            for await (const docs of cursor) {
-                for (const doc of docs.op === 'c' ? docs.o['applyOps'] : [docs]) {
-                    doc.ts = docs.ts;
-                    if (doc.op === 'i' || '_id' in doc.o) {
-                        const fields = new Set(Object.keys(doc.o));
-                        fields.delete('_id');
-                        yield { fields, doc };
-                    }
-                    else {
-                        if (doc.o['$v'] !== 2) {
-                            throw new Error(`Expected update with $v: 2, got ${JSON.stringify(doc)}`);
-                        }
-                        const updatedFields = [];
-                        const diff = doc.o['diff'];
-                        for (const updateOp in diff) {
-                            if (['u', 'i', 'd'].includes(updateOp)) {
-                                updatedFields.push(...Object.keys(diff[updateOp]));
-                            }
-                            else if (updateOp.startsWith('s')) {
-                                updatedFields.push(updateOp.slice(1));
-                            }
-                        }
-                        yield { fields: new Set(updatedFields), doc };
-                    }
-                }
-            }
-        }
-        catch (e) {
-            log('oplog loop error, notifying watchers and reopening');
-            console.error(e);
-            lastTs = await getCurrentTimestamp(db);
-            yield null;
-        }
-        finally {
-            log('oplog loop ended');
-            await cursor.close().catch(() => { });
-        }
-        await sleep(reopenDelayMs);
-    }
+	let lastTs = await getCurrentTimestamp(db);
+	const reopenDelayMs = 250;
+	const coll = db.client.db("local").collection("oplog.rs");
+	while (true) {
+		const cursor = coll.find({
+			ts: { $gt: lastTs },
+			$or: [{
+				ns: RegExp(`^${db.namespace}\\.(?!tmp_)(?!__).*(?<!_snapshot)$`),
+				op: { $in: ["i", "u"] }
+			}, {
+				ns: "admin.$cmd",
+				op: "c",
+				"o.applyOps": { $elemMatch: {
+					ns: RegExp(`^${db.namespace}\\.(?!tmp_)(?!__).*(?<!_snapshot)$`),
+					op: { $in: ["i", "u"] }
+				} }
+			}]
+		}, {
+			tailable: true,
+			awaitData: true,
+			noCursorTimeout: true
+		});
+		try {
+			for await (const docs of cursor) for (const doc of docs.op === "c" ? docs.o["applyOps"] : [docs]) {
+				doc.ts = docs.ts;
+				if (doc.op === "i" || "_id" in doc.o) {
+					const fields = new Set(Object.keys(doc.o));
+					fields.delete("_id");
+					yield {
+						fields,
+						doc
+					};
+				} else {
+					if (doc.o["$v"] !== 2) throw new Error(`Expected update with $v: 2, got ${JSON.stringify(doc)}`);
+					const updatedFields = [];
+					const diff = doc.o["diff"];
+					for (const updateOp in diff) if ([
+						"u",
+						"i",
+						"d"
+					].includes(updateOp)) updatedFields.push(...Object.keys(diff[updateOp]));
+					else if (updateOp.startsWith("s")) updatedFields.push(updateOp.slice(1));
+					yield {
+						fields: new Set(updatedFields),
+						doc
+					};
+				}
+			}
+		} catch (e) {
+			log("oplog loop error, notifying watchers and reopening");
+			console.error(e);
+			lastTs = await getCurrentTimestamp(db);
+			yield null;
+		} finally {
+			log("oplog loop ended");
+			await cursor.close().catch(() => {});
+		}
+		await sleep(reopenDelayMs);
+	}
 }
-const watchers = new Map();
+const watchers = /* @__PURE__ */ new Map();
 let running = false;
 const makePromise = () => {
-    let resolve = () => { };
-    let promise = new Promise(r => (resolve = r));
-    return { promise, resolve };
+	let resolve = () => {};
+	return {
+		promise: new Promise((r) => resolve = r),
+		resolve
+	};
 };
 const loop = async (db) => {
-    log('starting oplog loop');
-    let notify = makePromise();
-    let batch = [];
-    const run = async () => {
-        for await (const event of tailOplog(db)) {
-            if (event?.fields.size === 0)
-                continue;
-            batch = event && batch ? [...batch, event] : null;
-            notify.resolve();
-        }
-    };
-    run();
-    const iter = async function* () {
-        while (true) {
-            await notify.promise;
-            const b = batch;
-            batch = [];
-            notify = makePromise();
-            yield b;
-        }
-    };
-    for await (const events of iter()) {
-        if (!events) {
-            log('notifying watchers of oplog loop restart');
-            for (const m of watchers.values()) {
-                for (const { cb } of [...m.values()]) {
-                    cb(null);
-                }
-            }
-            continue;
-        }
-        for (const { fields, doc } of events) {
-            const m = watchers.get(doc.ns);
-            if (!m)
-                continue;
-            for (const { cb, keys, rem, match } of [...m.values()]) {
-                if (!keys || (doc.op === 'i' ? (match ? true : true) : keys.some(k => fields.has(k)))) {
-                    cb(doc);
-                    rem();
-                }
-            }
-        }
-    }
+	log("starting oplog loop");
+	let notify = makePromise();
+	let batch = [];
+	const run = async () => {
+		for await (const event of tailOplog(db)) {
+			if (event?.fields.size === 0) continue;
+			batch = event && batch ? [...batch, event] : null;
+			notify.resolve();
+		}
+	};
+	run();
+	const iter = async function* () {
+		while (true) {
+			await notify.promise;
+			const b = batch;
+			batch = [];
+			notify = makePromise();
+			yield b;
+		}
+	};
+	for await (const events of iter()) {
+		if (!events) {
+			log("notifying watchers of oplog loop restart");
+			for (const m of watchers.values()) for (const { cb } of [...m.values()]) cb(null);
+			continue;
+		}
+		for (const { fields, doc } of events) {
+			const m = watchers.get(doc.ns);
+			if (!m) continue;
+			for (const { cb, keys, rem, match } of [...m.values()]) if (!keys || (doc.op === "i" ? match ? true : true : keys.some((k) => fields.has(k)))) {
+				cb(doc);
+				rem();
+			}
+		}
+	}
 };
 const register = (coll, keys, match, cb) => {
-    const ns = coll.namespace;
-    let m = watchers.get(ns);
-    if (!m)
-        watchers.set(ns, (m = new Map()));
-    const id = crypto.randomUUID();
-    const rem = () => {
-        m.delete(id);
-        if (m.size === 0)
-            watchers.delete(ns);
-    };
-    m.set(id, { cb, keys, match, rem });
-    if (!running) {
-        running = true;
-        loop(coll.s.db);
-    }
-    return rem;
+	const ns = coll.namespace;
+	let m = watchers.get(ns);
+	if (!m) watchers.set(ns, m = /* @__PURE__ */ new Map());
+	const id = crypto.randomUUID();
+	const rem = () => {
+		m.delete(id);
+		if (m.size === 0) watchers.delete(ns);
+	};
+	m.set(id, {
+		cb,
+		keys,
+		match,
+		rem
+	});
+	if (!running) {
+		running = true;
+		loop(coll.s.db);
+	}
+	return rem;
 };
 let maxKeysRemoved = null;
 const makeWatchStream = async ({ collection, projection: p, hardMatch: m }, streamName) => {
-    const { db } = collection.s;
-    await (maxKeysRemoved ??= Promise.all((await db.listCollections({}, { nameOnly: true }).toArray()).map(x => void db
-        .collection(x.name)
-        .updateMany({ touchedAt: maxTimestamp }, [{ $set: { touchedAt: '$$CLUSTER_TIME' } }]))).then(() => { }));
-    const projection = { ...(p ? mapExactToObject(p, v => v) : {}), deletedAt: 1 };
-    let notify = makePromise();
-    register(collection, p ? Object.keys(projection) : null, m, doc => {
-        log(streamName, 'change detected', doc);
-        notify.resolve(doc);
-    });
-    return {
-        tryNext: async () => {
-            const doc = await notify.promise;
-            const start = Date.now();
-            if (doc)
-                await waitUntilStablePast(collection.s.db, doc.ts);
-            log(streamName, 'stable past took', Date.now() - start);
-            return doc ?? {};
-        },
-        close: async () => { },
-    };
+	const { db } = collection.s;
+	await (maxKeysRemoved ??= Promise.all((await db.listCollections({}, { nameOnly: true }).toArray()).map((x) => void db.collection(x.name).updateMany({ touchedAt: maxTimestamp }, [{ $set: { touchedAt: "$$CLUSTER_TIME" } }]))).then(() => {}));
+	const projection = {
+		...p ? mapExactToObject(p, (v) => v) : {},
+		deletedAt: 1
+	};
+	let notify = makePromise();
+	register(collection, p ? Object.keys(projection) : null, m, (doc) => {
+		log(streamName, "change detected", doc);
+		notify.resolve(doc);
+	});
+	return {
+		tryNext: async () => {
+			const doc = await notify.promise;
+			const start = Date.now();
+			if (doc) await waitUntilStablePast(collection.s.db, doc.ts);
+			log(streamName, "stable past took", Date.now() - start);
+			return doc ?? {};
+		},
+		close: async () => {}
+	};
 };
-
+//#endregion
+//#region .build/lib/boot/boot-utils.js
 const actions = {
-    updateMany: (c, args) => [
-        c.updateMany(...args),
-        [`db['${c.collectionName}'].updateMany(...`, args, ')'],
-    ],
-    deleteMany: (c, args) => [
-        c.deleteMany(...args),
-        [`db['${c.collectionName}'].deleteMany(...`, args, ')'],
-    ],
+	updateMany: (c, args) => [c.updateMany(...args), [
+		`db['${c.collectionName}'].updateMany(...`,
+		args,
+		")"
+	]],
+	deleteMany: (c, args) => [c.deleteMany(...args), [
+		`db['${c.collectionName}'].deleteMany(...`,
+		args,
+		")"
+	]]
 };
-
+//#endregion
+//#region .build/lib/query/logic.js
 const filterUndefined = (applyOperator) => {
-    return (op, args) => applyOperator(op, args.filter(defined));
+	return (op, args) => applyOperator(op, args.filter(defined));
 };
 const combine = (op, applyOperatorToPreItems) => (...args) => {
-    const mapToItems = applyOperatorToPreItems(op, args);
-    return mapToItems && { raw: field => mapToItems(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', filterUndefined(first));
-const $nor = combine('$nor', filterUndefined(all));
-const $or = combine('$or', filterUndefined(first));
-
-const previous = (ts) => new mongodb.Timestamp({ t: ts.high - 60, i: 0 });
+	const mapToItems = applyOperatorToPreItems(op, args);
+	return mapToItems && { raw: (field) => mapToItems((x) => x.raw(field)) };
+};
+const all = (op, x) => x.length === 0 ? void 0 : (f) => safeNarrow()({ [op]: x.map(f) });
+const first$1 = (op, x) => x.length === 1 ? (f) => f(x[0]) : all(op, x);
+const $and = combine("$and", filterUndefined(first$1));
+const $nor = combine("$nor", filterUndefined(all));
+const $or = combine("$or", filterUndefined(first$1));
+//#endregion
+//#region .build/lib/boot/first-stages.js
+const previous = (ts) => new mongodb.Timestamp({
+	t: ts.high - 60,
+	i: 0
+});
 const getFirstStages = (view, needs) => {
-    const { projection, hardMatch: pre, match } = view;
-    const projectInput = projection && $project_(spread(projection, {
-        deletedAt: ['deletedAt', 1],
-        _id: ['_id', 1],
-    }));
-    const removeNotYetSynchronizedFields = projection && Object.values(mapExactToObject(projection, (_, k) => (needs[k] ?? k.startsWith('_')) ? root().of(k).has($exists(true)) : null));
-    const hardMatch = removeNotYetSynchronizedFields ? $and(pre, ...removeNotYetSynchronizedFields) : pre;
-    const firstStages = (lastTS, keepNulls = false) => {
-        const hardQuery = $and(lastTS
-            ? root().of('touchedAt').has($gtTs(previous(lastTS.ts)))
-            : root().of('deletedAt').has($eq(null)), lastTS ? null : match && $expr(match), keepNulls ? pre : hardMatch);
-        const ln = link()
-            .with($match_(hardQuery));
-        return (projectInput ? ln.with(projectInput) : ln);
-    };
-    return { firstStages, hardMatch };
+	const { projection, hardMatch: pre, match } = view;
+	const projectInput = projection && $project_(spread(projection, {
+		deletedAt: ["deletedAt", 1],
+		_id: ["_id", 1]
+	}));
+	const removeNotYetSynchronizedFields = projection && Object.values(mapExactToObject(projection, (_, k) => needs[k] ?? k.startsWith("_") ? root().of(k).has($exists(true)) : null));
+	const hardMatch = removeNotYetSynchronizedFields ? $and(pre, ...removeNotYetSynchronizedFields) : pre;
+	const firstStages = (lastTS, keepNulls = false) => {
+		const hardQuery = $and(lastTS ? root().of("touchedAt").has($gtTs(previous(lastTS.ts))) : root().of("deletedAt").has($eq(null)), lastTS ? null : match && $expr(match), keepNulls ? pre : hardMatch);
+		const ln = link().with($match_(hardQuery));
+		return projectInput ? ln.with(projectInput) : ln;
+	};
+	return {
+		firstStages,
+		hardMatch
+	};
 };
-
+//#endregion
+//#region .build/lib/boot/boot.js
 const streamNames = {};
 const executes$2 = (view, input, streamName, skip = false, after, needs = {}) => {
-    const { collection, projection, match } = view;
-    const { firstStages, hardMatch } = getFirstStages(view, needs);
-    const db = collection.s.db, coll = collection.collectionName;
-    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 ${streamName} already used`);
-    const last = db.collection('__last');
-    const snapshotCollection = db.collection(coll + '_' + streamName + '_snapshot');
-    const job = {};
-    const run = (finalInput, setup) => {
-        const dropSnapshot = async () => {
-            await snapshotCollection.drop().catch(noop);
-            log('snapshot collection dropped', streamName, `db['${snapshotCollection.collectionName}'].drop()`);
-            log('with', [...(indexMap.get(snapshotCollection.collectionName)?.keys() ?? [])], 'indexes in map before deletion');
-            indexMap.delete(snapshotCollection.collectionName);
-        };
-        const clear = async () => Promise.all([dropSnapshot(), last.deleteOne({ _id: streamName })]);
-        const withStop = (next, tr) => {
-            return addTeardown(() => ({ stop, next: next(), clear }), tr);
-        };
-        const nextData = (data, job) => (next, debug, tr) => ({
-            cont: withStop(next, tr),
-            data,
-            info: { job, debug: `${streamName} on ${collection.collectionName}: ${debug}` },
-        });
-        const next = nextData([], job);
-        const data = {
-            input: input.delta,
-            finalInputFirst: finalInput.raw(true),
-            finalInput: finalInput.raw(false),
-            match: view.match?.raw(root()).get(),
-            project: projection,
-            teardown: finalInput.teardown((x) => ({
-                collection: x.collection.collectionName,
-                method: x.method,
-                params: x.params,
-            })),
-        };
-        const step0 = () => Promise.resolve(next(step1, 'empty new collection'));
-        const stop = withStop(step0);
-        const step1 = async () => {
-            log('reset collection', streamName, `db['${snapshotCollection.collectionName}'].updateMany( updated: true }, { $set: { updated: false, after: null } })`);
-            await snapshotCollection.updateMany({ updated: true }, { $set: { updated: false, after: null } });
-            log('reset collection done', streamName);
-            return next(step2, 'get last update');
-        };
-        const step2 = () => Promise.all([
-            last.findOne({ _id: streamName, data, job: null }),
-            last.findOne({ _id: streamName }),
-        ]).then(ts => next(step2_5(ts), ts[0]
-            ? `no teardown to handle, starting at ${ts[0].ts}`
-            : ts[1]
-                ? 'handle teardown'
-                : 'start fresh'));
-        const step2_5 = ([same, exists]) => async () => {
-            const handleTeardown = async (last) => {
-                if (!last.data)
-                    return;
-                const { collection: c, method: m, params: p } = last.data.teardown;
-                const { collection, method, params } = {
-                    collection: db.collection(c),
-                    method: m,
-                    params: p,
-                };
-                const [action, out] = actions[method](collection, params);
-                log('teardown', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
-                await Promise.all([dropSnapshot(), action]);
-                log('teardown done', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
-            };
-            if (!same) {
-                log('not same, new data', streamName, data);
-                await handleTeardown(exists ?? { data });
-            }
-            log('creating indexes');
-            await createIndex(snapshotCollection, { before: 1 }, {
-                partialFilterExpression: { before: null },
-                name: 'before_' + new mongodb.UUID().toString('base64'),
-            });
-            await createIndex(snapshotCollection, { updated: 1 }, {
-                partialFilterExpression: { updated: true },
-                name: 'updated_' + new mongodb.UUID().toString('base64'),
-            });
-            await createIndex(snapshotCollection, { updated: 1, after: 1, before: 1 }, {
-                partialFilterExpression: { updated: true, after: null, before: null },
-                name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
-            });
-            await createIndex(snapshotCollection, { updated: 1, after: 1 }, {
-                partialFilterExpression: { updated: true, after: null },
-                name: 'updated_no_after_' + new mongodb.UUID().toString('base64'),
-            });
-            await createIndex(snapshotCollection, { updated: 1 }, {
-                partialFilterExpression: { updated: true, after: null, before: null },
-                name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
-            });
-            await ensureCollection(db, coll);
-            await db.command({
-                collMod: coll,
-                changeStreamPreAndPostImages: { enabled: true },
-            });
-            await createIndex(collection, { touchedAt: 1 }, hardMatch
-                ? {
-                    partialFilterExpression: hardMatch.raw(root()),
-                    name: 'touchedAt_hard_' + new mongodb.UUID().toString('base64'),
-                }
-                : {});
-            await setup?.();
-            await after?.();
-            return nextData([])(async () => {
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                return next(step3(same), 'clone into new collection');
-            }, 'wait for clone into new collection');
-        };
-        const step3 = (lastTS) => async () => {
-            const notDeleted = eq($ifNull(root().of('deletedAt').expr(), nil))(nil);
-            const query = match ? and(notDeleted, match) : notDeleted;
-            const replaceRaw = $replaceWith_(field({
-                after: ['after', lastTS ? ite(query, root().expr(), nil) : root().expr()],
-                updated: ['updated', val(true)],
-                _id: ['_id', root().of('_id').expr()],
-            }));
-            const cloneIntoNew = firstStages(lastTS)
-                .with(replaceRaw)
-                .with($merge_({
-                into: snapshotCollection,
-                on: root().of('_id'),
-                stages: 'ctx',
-                vars: {
-                    new: ['new', root().expr()],
-                },
-                whenMatched: link().with($replaceWith_(ite(eq(root().of('before').expr())(ctx()('new').of('after').expr()), root().expr(), mergeObjects(root().expr(), ctx()('new').expr())))).stages,
-                whenNotMatched: 'insert',
-            })).stages;
-            const stream = await makeStream();
-            const r = await aggregate(db, streamName, c => c({ coll: collection, input: cloneIntoNew }));
-            const start = Date.now();
-            const res = await snapshotCollection.deleteMany({ updated: true, after: null, before: null });
-            log('deleting from cloned into new collection', Date.now() - start, res, `db['${snapshotCollection.collectionName}'].deleteMany({ updated: true, after: null, before: null })`);
-            return next(step4({ result: r, ts: lastTS?.ts, stream }), 'run the aggregation', () => stream.close());
-        };
-        const makeStream = () => makeWatchStream(view, streamName);
-        const step4 = ({ result, ts, stream }) => async () => {
-            const start = Date.now();
-            log('snapshot', streamName, 'ensure before null', Date.now() - start);
-            const first = ts === undefined;
-            const stages = finalInput.raw(first);
-            await last.updateOne({ _id: streamName }, { $set: { job: 1 } }, { upsert: true });
-            const nextRes = stream.tryNext();
-            const aggResult = await aggregate(db, streamName, c => c({
-                coll: snapshotCollection,
-                input: link()
-                    .with($match_(root().of('updated').has($eq(true))))
-                    .with($set_(set()({
-                    before: [
-                        'before',
-                        to($ifNull(root().of('before').expr(), nil)),
-                    ],
-                })))
-                    .with(input.delta)
-                    .with(stages).stages,
-            }), false, start);
-            stages.at(-1).$merge.into.coll;
-            return next(step5({ ts: result.cursor.atClusterTime, aggResult, stream, nextRes, first }), 'remove handled deleted updated');
-        };
-        const step5 = (l) => async () => {
-            log(streamName, `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' } } ])`);
-            const start = Date.now();
-            await snapshotCollection.updateMany({ updated: true }, [
-                {
-                    $set: {
-                        updated: false,
-                        after: null,
-                        before: '$after',
-                    },
-                },
-            ]);
-            log('updated snapshot aggregation', Date.now() - start);
-            return next(step7(l), 'update __last');
-        };
-        const step7 = (l) => async () => {
-            const start = Date.now();
-            const patch = {
-                $set: {
-                    ts: l.ts,
-                    job: null,
-                },
-            };
-            if (l.first)
-                patch.$set = { ...patch.$set, data };
-            await last.updateOne({ _id: streamName }, patch, { upsert: true });
-            log('updated __last', Date.now() - start, `db['${last.collectionName}'].updateOne({ _id: '${streamName}' }, `, patch, `, { upsert: true })`);
-            return step8(l);
-        };
-        const step8 = (l) => {
-            return nextData(l.aggResult.cursor.firstBatch)(() => l.nextRes.then(doc => doc
-                ? next(step3({ _id: streamName, ts: l.ts }), 'restart')
-                : step8({ ...l, nextRes: l.stream.tryNext() })), 'wait for change');
-        };
-        return skip
-            ? withStop(() => Promise.resolve(next(step3(null), 'clone into new collection')))
-            : 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, skip = false, after) => pipe(input => executes$2(view, input, streamName, skip, after, view.needs), emptyDelta(), concatDelta, emptyDelta);
-
+	const { collection, projection, match } = view;
+	const { firstStages, hardMatch } = getFirstStages(view, needs);
+	const db = collection.s.db, coll = collection.collectionName;
+	const hash = crypto$1.default.createHash("md5").update((/* @__PURE__ */ new Error()).stack + "").digest("base64url");
+	if (!streamNames[streamName]) streamNames[streamName] = hash;
+	else if (streamNames[streamName] != hash) throw new Error(`streamName ${streamName} already used`);
+	const last = db.collection("__last");
+	const snapshotCollection = db.collection(coll + "_" + streamName + "_snapshot");
+	const job = {};
+	const run = (finalInput, setup) => {
+		const dropSnapshot = async () => {
+			await snapshotCollection.drop().catch(noop);
+			log("snapshot collection dropped", streamName, `db['${snapshotCollection.collectionName}'].drop()`);
+			log("with", [...indexMap.get(snapshotCollection.collectionName)?.keys() ?? []], "indexes in map before deletion");
+			indexMap.delete(snapshotCollection.collectionName);
+		};
+		const clear = async () => Promise.all([dropSnapshot(), last.deleteOne({ _id: streamName })]);
+		const withStop = (next, tr) => {
+			return addTeardown(() => ({
+				stop,
+				next: next(),
+				clear
+			}), tr);
+		};
+		const nextData = (data, job) => (next, debug, tr) => ({
+			cont: withStop(next, tr),
+			data,
+			info: {
+				job,
+				debug: `${streamName} on ${collection.collectionName}: ${debug}`
+			}
+		});
+		const next = nextData([], job);
+		const data = {
+			input: input.delta,
+			finalInputFirst: finalInput.raw(true),
+			finalInput: finalInput.raw(false),
+			match: view.match?.raw(root()).get(),
+			project: projection,
+			teardown: finalInput.teardown((x) => ({
+				collection: x.collection.collectionName,
+				method: x.method,
+				params: x.params
+			}))
+		};
+		const step0 = () => Promise.resolve(next(step1, "empty new collection"));
+		const stop = withStop(step0);
+		const step1 = async () => {
+			log("reset collection", streamName, `db['${snapshotCollection.collectionName}'].updateMany( updated: true }, { $set: { updated: false, after: null } })`);
+			await snapshotCollection.updateMany({ updated: true }, { $set: {
+				updated: false,
+				after: null
+			} });
+			log("reset collection done", streamName);
+			return next(step2, "get last update");
+		};
+		const step2 = () => Promise.all([last.findOne({
+			_id: streamName,
+			data,
+			job: null
+		}), last.findOne({ _id: streamName })]).then((ts) => next(step2_5(ts), ts[0] ? `no teardown to handle, starting at ${ts[0].ts}` : ts[1] ? "handle teardown" : "start fresh"));
+		const step2_5 = ([same, exists]) => async () => {
+			const handleTeardown = async (last) => {
+				if (!last.data) return;
+				const { collection: c, method: m, params: p } = last.data.teardown;
+				const { collection, method, params } = {
+					collection: db.collection(c),
+					method: m,
+					params: p
+				};
+				const [action, out] = actions[method](collection, params);
+				log("teardown", `db['${snapshotCollection.collectionName}'].drop()`, ...out);
+				await Promise.all([dropSnapshot(), action]);
+				log("teardown done", `db['${snapshotCollection.collectionName}'].drop()`, ...out);
+			};
+			if (!same) {
+				log("not same, new data", streamName, data);
+				await handleTeardown(exists ?? { data });
+			}
+			log("creating indexes");
+			await createIndex(snapshotCollection, { before: 1 }, {
+				partialFilterExpression: { before: null },
+				name: "before_" + new mongodb.UUID().toString("base64")
+			});
+			await createIndex(snapshotCollection, { updated: 1 }, {
+				partialFilterExpression: { updated: true },
+				name: "updated_" + new mongodb.UUID().toString("base64")
+			});
+			await createIndex(snapshotCollection, {
+				updated: 1,
+				after: 1,
+				before: 1
+			}, {
+				partialFilterExpression: {
+					updated: true,
+					after: null,
+					before: null
+				},
+				name: "updated_nulls_" + new mongodb.UUID().toString("base64")
+			});
+			await createIndex(snapshotCollection, {
+				updated: 1,
+				after: 1
+			}, {
+				partialFilterExpression: {
+					updated: true,
+					after: null
+				},
+				name: "updated_no_after_" + new mongodb.UUID().toString("base64")
+			});
+			await createIndex(snapshotCollection, { updated: 1 }, {
+				partialFilterExpression: {
+					updated: true,
+					after: null,
+					before: null
+				},
+				name: "updated_nulls_" + new mongodb.UUID().toString("base64")
+			});
+			await ensureCollection(db, coll);
+			await db.command({
+				collMod: coll,
+				changeStreamPreAndPostImages: { enabled: true }
+			});
+			await createIndex(collection, { touchedAt: 1 }, hardMatch ? {
+				partialFilterExpression: hardMatch.raw(root()),
+				name: "touchedAt_hard_" + new mongodb.UUID().toString("base64")
+			} : {});
+			await setup?.();
+			await after?.();
+			return nextData([])(async () => {
+				await new Promise((resolve) => setTimeout(resolve, 1e3));
+				return next(step3(same), "clone into new collection");
+			}, "wait for clone into new collection");
+		};
+		const step3 = (lastTS) => async () => {
+			const notDeleted = eq($ifNull(root().of("deletedAt").expr(), nil))(nil);
+			const query = match ? and(notDeleted, match) : notDeleted;
+			const replaceRaw = $replaceWith_(field({
+				after: ["after", lastTS ? ite(query, root().expr(), nil) : root().expr()],
+				updated: ["updated", val(true)],
+				_id: ["_id", root().of("_id").expr()]
+			}));
+			const cloneIntoNew = firstStages(lastTS).with(replaceRaw).with($merge_({
+				into: snapshotCollection,
+				on: root().of("_id"),
+				stages: "ctx",
+				vars: { new: ["new", root().expr()] },
+				whenMatched: link().with($replaceWith_(ite(eq(root().of("before").expr())(ctx()("new").of("after").expr()), root().expr(), mergeObjects(root().expr(), ctx()("new").expr())))).stages,
+				whenNotMatched: "insert"
+			})).stages;
+			const stream = await makeStream();
+			const r = await aggregate(db, streamName, (c) => c({
+				coll: collection,
+				input: cloneIntoNew
+			}));
+			const start = Date.now();
+			const res = await snapshotCollection.deleteMany({
+				updated: true,
+				after: null,
+				before: null
+			});
+			log("deleting from cloned into new collection", Date.now() - start, res, `db['${snapshotCollection.collectionName}'].deleteMany({ updated: true, after: null, before: null })`);
+			return next(step4({
+				result: r,
+				ts: lastTS?.ts,
+				stream
+			}), "run the aggregation", () => stream.close());
+		};
+		const makeStream = () => makeWatchStream(view, streamName);
+		const step4 = ({ result, ts, stream }) => async () => {
+			const start = Date.now();
+			log("snapshot", streamName, "ensure before null", Date.now() - start);
+			const first = ts === void 0;
+			const stages = finalInput.raw(first);
+			await last.updateOne({ _id: streamName }, { $set: { job: 1 } }, { upsert: true });
+			const nextRes = stream.tryNext();
+			const aggResult = await aggregate(db, streamName, (c) => c({
+				coll: snapshotCollection,
+				input: link().with($match_(root().of("updated").has($eq(true)))).with($set_(set()({ before: ["before", to($ifNull(root().of("before").expr(), nil))] }))).with(input.delta).with(stages).stages
+			}), false, start);
+			return next(step5({
+				ts: result.cursor.atClusterTime,
+				aggResult,
+				stream,
+				nextRes,
+				first
+			}), "remove handled deleted updated");
+		};
+		const step5 = (l) => async () => {
+			log(streamName, `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' } } ])`);
+			const start = Date.now();
+			await snapshotCollection.updateMany({ updated: true }, [{ $set: {
+				updated: false,
+				after: null,
+				before: "$after"
+			} }]);
+			log("updated snapshot aggregation", Date.now() - start);
+			return next(step7(l), "update __last");
+		};
+		const step7 = (l) => async () => {
+			const start = Date.now();
+			const patch = { $set: {
+				ts: l.ts,
+				job: null
+			} };
+			if (l.first) patch.$set = {
+				...patch.$set,
+				data
+			};
+			await last.updateOne({ _id: streamName }, patch, { upsert: true });
+			log("updated __last", Date.now() - start, `db['${last.collectionName}'].updateOne({ _id: '${streamName}' }, `, patch, `, { upsert: true })`);
+			return step8(l);
+		};
+		const step8 = (l) => {
+			return nextData(l.aggResult.cursor.firstBatch)(() => l.nextRes.then((doc) => doc ? next(step3({
+				_id: streamName,
+				ts: l.ts
+			}), "restart") : step8({
+				...l,
+				nextRes: l.stream.tryNext()
+			})), "wait for change");
+		};
+		return skip ? withStop(() => Promise.resolve(next(step3(null), "clone into new collection"))) : 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, skip = false, after) => pipe((input) => executes$2(view, input, streamName, skip, after, view.needs), emptyDelta(), concatDelta, emptyDelta);
+//#endregion
+//#region .build/lib/boot/boot-simpl.js
 const executes$1 = (view, input, streamName, needs) => {
-    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: pre, match } = view;
-    const removeNotYetSynchronizedFields = projection &&
-        Object.values(mapExactToObject(projection, (_, k) => (needs[k] ?? k.startsWith('_')) ? root().of(k).has($exists(true)) : null));
-    const hardMatch = removeNotYetSynchronizedFields
-        ? $and(pre, ...removeNotYetSynchronizedFields)
-        : pre;
-    const job = {};
-    const db = collection.s.db, coll = collection.collectionName;
-    const last = db.collection('__last');
-    const projectInput = projection &&
-        $project_(spread(projection, {
-            deletedAt: ['deletedAt', 1],
-            _id: ['_id', 1],
-        }));
-    const notDeleted = root().of('deletedAt').has($eq(null));
-    const stages = (lastTS) => {
-        const hardQuery = $and(lastTS && root().of('touchedAt').has($gteTs(previous(lastTS.ts))), hardMatch, notDeleted, match && $expr(match));
-        const ln = link().with($match_(hardQuery));
-        return (projectInput ? ln.with(projectInput) : ln).with(input);
-    };
-    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 data = {
-            input: input,
-            finalInputFirst: finalInput.raw(true),
-            finalInput: finalInput.raw(false),
-            match: view.match?.raw(root()).get(),
-            project: projection,
-            teardown: finalInput.teardown((x) => ({
-                collection: x.collection.collectionName,
-                method: x.method,
-                params: x.params,
-            })),
-        };
-        const step0 = () => Promise.resolve(next(step1, 'get last update'));
-        const stop = withStop(step0);
-        const step1 = async () => {
-            log('creating indexes');
-            await ensureCollection(db, coll);
-            await db.command({
-                collMod: coll,
-                changeStreamPreAndPostImages: { enabled: true },
-            });
-            await createIndex(collection, { touchedAt: 1 }, {
-                partialFilterExpression: { deletedAt: { $eq: null } },
-                name: 'touchedAt_' + new mongodb.UUID().toString('base64'),
-            });
-            log('stream started', { streamName, data });
-            const ts = await Promise.all([
-                last.findOne({ _id: streamName, data }),
-                last.findOne({ _id: streamName }),
-            ]);
-            log('got last update', { streamName, ts });
-            return next(step2_5(ts), 'handle teardown');
-        };
-        const step2_5 = ([same, exists]) => async () => {
-            const handleTeardown = async (last) => {
-                if (!last.data)
-                    return;
-                const { collection: c, method: m, params: p } = last.data.teardown;
-                const { collection, method, params } = {
-                    collection: db.collection(c),
-                    method: m,
-                    params: p,
-                };
-                const [action, out] = actions[method](collection, params);
-                log('teardown', ...out);
-                await action;
-                log('teardown done', ...out);
-            };
-            if (exists && !same)
-                await handleTeardown(exists);
-            return {
-                cont: withStop(async () => {
-                    await new Promise(resolve => setTimeout(resolve, 1000));
-                    return next(step4(same), 'clone into new collection');
-                }),
-                data: [],
-                info: { debug: 'wait for clone into new collection', job: undefined },
-            };
-        };
-        const makeStream = () => makeWatchStream(view, streamName);
-        const step4 = (lastTS) => async () => {
-            const raw = stages(lastTS).with(finalInput.raw(lastTS === null)).stages;
-            const stream = await makeStream();
-            const nextRes = stream.tryNext();
-            const aggResult = await aggregate(db, streamName, c => c({
-                coll: collection,
-                input: raw,
-            }));
-            return next(step7({ aggResult, ts: aggResult.cursor.atClusterTime, stream, nextRes }), 'update __last', () => stream.close());
-        };
-        const step7 = (l) => async () => {
-            await last.updateOne({ _id: streamName }, { $set: { ts: l.ts, data } }, { upsert: true });
-            return step8(l);
-        };
-        const step8 = (l) => {
-            return {
-                data: l.aggResult.cursor.firstBatch,
-                info: { job: undefined, debug: 'wait for change' },
-                cont: withStop(() => l.nextRes.then(doc => doc
-                    ? next(step4({ _id: streamName, ts: l.ts }), 'restart')
-                    : step8({ ...l, nextRes: l.stream.tryNext() }))),
-            };
-        };
-        return stop;
-    };
-    return {
-        out: run,
-    };
+	const hash = crypto$1.default.createHash("md5").update((/* @__PURE__ */ 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: pre, match } = view;
+	const removeNotYetSynchronizedFields = projection && Object.values(mapExactToObject(projection, (_, k) => needs[k] ?? k.startsWith("_") ? root().of(k).has($exists(true)) : null));
+	const hardMatch = removeNotYetSynchronizedFields ? $and(pre, ...removeNotYetSynchronizedFields) : pre;
+	const job = {};
+	const db = collection.s.db, coll = collection.collectionName;
+	const last = db.collection("__last");
+	const projectInput = projection && $project_(spread(projection, {
+		deletedAt: ["deletedAt", 1],
+		_id: ["_id", 1]
+	}));
+	const notDeleted = root().of("deletedAt").has($eq(null));
+	const stages = (lastTS) => {
+		const hardQuery = $and(lastTS && root().of("touchedAt").has($gteTs(previous(lastTS.ts))), hardMatch, notDeleted, match && $expr(match));
+		const ln = link().with($match_(hardQuery));
+		return (projectInput ? ln.with(projectInput) : ln).with(input);
+	};
+	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 data = {
+			input,
+			finalInputFirst: finalInput.raw(true),
+			finalInput: finalInput.raw(false),
+			match: view.match?.raw(root()).get(),
+			project: projection,
+			teardown: finalInput.teardown((x) => ({
+				collection: x.collection.collectionName,
+				method: x.method,
+				params: x.params
+			}))
+		};
+		const step0 = () => Promise.resolve(next(step1, "get last update"));
+		const stop = withStop(step0);
+		const step1 = async () => {
+			log("creating indexes");
+			await ensureCollection(db, coll);
+			await db.command({
+				collMod: coll,
+				changeStreamPreAndPostImages: { enabled: true }
+			});
+			await createIndex(collection, { touchedAt: 1 }, {
+				partialFilterExpression: { deletedAt: { $eq: null } },
+				name: "touchedAt_" + new mongodb.UUID().toString("base64")
+			});
+			log("stream started", {
+				streamName,
+				data
+			});
+			const ts = await Promise.all([last.findOne({
+				_id: streamName,
+				data
+			}), last.findOne({ _id: streamName })]);
+			log("got last update", {
+				streamName,
+				ts
+			});
+			return next(step2_5(ts), "handle teardown");
+		};
+		const step2_5 = ([same, exists]) => async () => {
+			const handleTeardown = async (last) => {
+				if (!last.data) return;
+				const { collection: c, method: m, params: p } = last.data.teardown;
+				const { collection, method, params } = {
+					collection: db.collection(c),
+					method: m,
+					params: p
+				};
+				const [action, out] = actions[method](collection, params);
+				log("teardown", ...out);
+				await action;
+				log("teardown done", ...out);
+			};
+			if (exists && !same) await handleTeardown(exists);
+			return {
+				cont: withStop(async () => {
+					await new Promise((resolve) => setTimeout(resolve, 1e3));
+					return next(step4(same), "clone into new collection");
+				}),
+				data: [],
+				info: {
+					debug: "wait for clone into new collection",
+					job: void 0
+				}
+			};
+		};
+		const makeStream = () => makeWatchStream(view, streamName);
+		const step4 = (lastTS) => async () => {
+			const raw = stages(lastTS).with(finalInput.raw(lastTS === null)).stages;
+			const stream = await makeStream();
+			const nextRes = stream.tryNext();
+			const aggResult = await aggregate(db, streamName, (c) => c({
+				coll: collection,
+				input: raw
+			}));
+			return next(step7({
+				aggResult,
+				ts: aggResult.cursor.atClusterTime,
+				stream,
+				nextRes
+			}), "update __last", () => stream.close());
+		};
+		const step7 = (l) => async () => {
+			await last.updateOne({ _id: streamName }, { $set: {
+				ts: l.ts,
+				data
+			} }, { upsert: true });
+			return step8(l);
+		};
+		const step8 = (l) => {
+			return {
+				data: l.aggResult.cursor.firstBatch,
+				info: {
+					job: void 0,
+					debug: "wait for change"
+				},
+				cont: withStop(() => l.nextRes.then((doc) => doc ? next(step4({
+					_id: streamName,
+					ts: l.ts
+				}), "restart") : step8({
+					...l,
+					nextRes: l.stream.tryNext()
+				})))
+			};
+		};
+		return stop;
+	};
+	return { out: run };
 };
 const emptyLin = () => ({ lin: link().stages });
-const from = (view, streamName, needs = {}) => pipe(input => executes$1(view, input.lin, streamName, needs), { lin: link().stages }, ({ lin: a }, { lin: b }) => ({ lin: concatStages(a, b) }), emptyLin);
-
+const from = (view, streamName, needs = {}) => pipe((input) => executes$1(view, input.lin, streamName, needs), { lin: link().stages }, ({ lin: a }, { lin: b }) => ({ lin: concatStages(a, b) }), emptyLin);
+//#endregion
+//#region .build/lib/boot/single.js
 const executes = (view, input, needs) => {
-    const { firstStages } = getFirstStages(view, needs);
-    const { collection } = view;
-    return (finalInput) => {
-        const start = input.raw(root);
-        const stages = firstStages(null, true).with(start).with(finalInput).stages;
-        return c => c({
-            coll: collection,
-            input: link().stages,
-            exec: stages,
-        });
-    };
-};
-const single = (view, needs = {}) => pipe(input => executes(view, input, needs), emptyDelta(), concatDelta, emptyDelta);
-
-require('dotenv').config();
-const uri = process.env['MONGO_URL'];
-
+	const { firstStages } = getFirstStages(view, needs);
+	const { collection } = view;
+	return (finalInput) => {
+		const start = input.raw(root);
+		const stages = firstStages(null, true).with(start).with(finalInput).stages;
+		return (c) => c({
+			coll: collection,
+			input: link().stages,
+			exec: stages
+		});
+	};
+};
+const single = (view, needs = {}) => pipe((input) => executes(view, input, needs), emptyDelta(), concatDelta, emptyDelta);
+//#endregion
+//#region .build/test/uri.js
+require("dotenv").config();
+const uri = process.env["MONGO_URL"];
+//#endregion
+//#region .build/test/mongodb.js
 const enablePreAndPostImages = (coll) => coll.s.db.command({
-    collMod: coll.collectionName,
-    changeStreamPreAndPostImages: { enabled: true },
+	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;
+	const client = new mongodb.MongoClient(uri, testName ? { monitorCommands: true } : {});
+	if (testName) {
+		const handler = (c) => {
+			(0, fs_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;
 };
+const clears = [];
 const makeCol = async (docs, database, name) => {
-    if (!name) {
-        (name = crypto.randomUUID());
-    }
-    try {
-        const col = await database.createCollection(name, {
-            changeStreamPreAndPostImages: { enabled: true },
-        });
-        if (docs.length)
-            await col.insertMany([...docs]);
-        return col;
-    }
-    catch {
-        return database.collection(name);
-    }
+	if (!name) {
+		const n = name = crypto.randomUUID();
+		clears.push(async () => {
+			await database.collection(n).drop({ ignoreUndefined: true });
+		});
+	}
+	try {
+		const col = await database.createCollection(name, { changeStreamPreAndPostImages: { enabled: true } });
+		if (docs.length) await col.insertMany([...docs]);
+		return col;
+	} catch {
+		return database.collection(name);
+	}
 };
-
+//#endregion
 exports.$accumulator = $accumulator;
 exports.$and = $and;
 exports.$countDict = $countDict;
@@ -2509,23 +2275,21 @@ exports.divide = divide;
 exports.emptyDelta = emptyDelta;
 exports.enablePreAndPostImages = enablePreAndPostImages;
 exports.eq = eq;
-exports.eqExtends = eqExtends;
-exports.eqPar = eqPar;
 exports.eqTyped = eqTyped;
 exports.except = except;
-exports.excludeIdem = excludeIdem;
 exports.exprMapVal = exprMapVal;
 exports.field = field;
 exports.fieldF = fieldF;
 exports.fieldM = fieldM;
 exports.filter = filter;
 exports.filterDefined = filterDefined;
-exports.first = first$1;
+exports.first = first;
 exports.firstSure = firstSure;
 exports.floor = floor;
 exports.from = from;
 exports.fromEq = fromEq;
 exports.func = func;
+exports.getSubsetMatchForExt = getSubsetMatchForExt;
 exports.getWhenMatched = getWhenMatched;
 exports.getWhenMatchedForMerge = getWhenMatchedForMerge;
 exports.gt = gt;
@@ -2568,9 +2332,6 @@ exports.noop = noop;
 exports.not = not;
 exports.notNull = notNull;
 exports.now = now;
-exports.omitExclude = omitExclude;
-exports.omitPick = omitPick;
-exports.omitRORec = omitRORec;
 exports.or = or;
 exports.padLeft = padLeft;
 exports.prepare = prepare;
@@ -2578,7 +2339,6 @@ exports.rand = rand;
 exports.range = range;
 exports.reflex = reflex;
 exports.regex = regex;
-exports.renamedFields = renamedFields;
 exports.root = root;
 exports.set = set;
 exports.setField = setField;
@@ -2596,8 +2356,9 @@ exports.subtract = subtract;
 exports.sym = sym;
 exports.to = to;
 exports.toInt = toInt;
-exports.translateOmit = translateOmit;
 exports.val = val;
 exports.weekPart = weekPart;
 exports.wrap = wrap;
 exports.year = year;
+
+//# sourceMappingURL=index.js.map