@omegup/msync 0.1.55 → 0.1.57

package/README.md

@@ -0,0 +1,388 @@
+# @omegup/msync
+
+[![npm](https://img.shields.io/npm/v/@omegup/msync)](https://www.npmjs.com/package/@omegup/msync)
+
+`msync` keeps derived MongoDB data in sync with the documents it comes from.
+
+You describe the derivation the way you would write an aggregation: project the fields you read, join, reshape, group, and write the result back. `msync` runs that description once over the existing data, then again on every change. Joins, sums, and counts update from the delta. A removed source undoes the write that depended on it. A changed source rewrites only the documents that depend on it.
+
+## Install
+
+```bash
+npm install @omegup/msync
+```
+
+Peer runtime: MongoDB with change streams (a replica set), and TypeScript. `msync` enables change-stream pre- and post-images on every collection it watches.
+
+```ts
+import { Machine, from, staging } from '@omegup/msync'
+```
+
+## The principle
+
+A stream is a named, typed function from source documents to stored documents.
+
+1. **Sources are ordinary collections.** Every document `msync` reads or writes is a `Model`: it has `_id`, `touchedAt`, and `deletedAt`. `touchedAt` is the cluster time of the last write. `deletedAt: null` means the document is alive; a timestamp means it was removed. Deletes are soft, so a stream can see that a document went away and undo what it had written.
+
+2. **You declare the slice you read.** A view is a collection plus a projection. The projection is the only data the rest of the pipeline is allowed to see, and the types follow it.
+
+3. **Stages are valid as a full pass and as a delta.** `$lookup`, `$set`, `$replaceWith`, `$match`, and `$unwind` each know how to run over a snapshot and how to run over a before/after pair. You write them once.
+
+4. **The last stage writes.** `$simpleMerge` and `$merge` patch fields onto an existing document. `$group` and `$groupId` fold many documents into one and keep the fold incremental. `$insert` creates documents in another collection and soft-deletes them when the source disappears.
+
+5. **The name is the identity of the job.** Progress lives in a `__last` document keyed by that name. If the pipeline you registered under the name changes, `msync` tears the previous output down (unsets the fields it wrote, or soft-deletes the documents it inserted) and rebuilds.
+
+6. **Streams compose by reading each other's fields.** A field whose name starts with `_` is treated as derived. A later stream that projects `_accountName` waits until that field exists, so you can add every stream to one machine and they still line up.
+
+```
+source collection
+    │  change stream (pre-image + post-image)
+    ▼
+view  ── projection, optional match
+    │
+stages ── lookup, set, replace, match, unwind
+    │
+sink  ── merge | group | insert
+    │
+    ▼
+same collection, or another one
+```
+
+Two ways in:
+
+| | `from` | `staging` |
+|---|---|---|
+| Use it when | The current document is enough, and you patch it in place | You join, group, insert, or need the previous value |
+| What it stores | The resume token in `__last` | A `{collection}_{name}_snapshot` of before/after, plus `__last` |
+| Sink | `$simpleMerge`, `$simpleInsert` | `$merge`, `$group`, `$groupId`, `$insert` |
+| Can be the right side of `$lookup` | | Yes, after `.get()` |
+
+`single` builds the same snapshot pipeline without the watch loop, for a one-shot read.
+
+## A document
+
+```ts
+import type { Model } from '@omegup/msync'
+
+// Model is { _id, touchedAt, deletedAt? } intersected with your fields.
+type Account = {
+  _id: string
+  name: string
+  createdAt: Date
+  _cohort?: string | null   // written by a stream, e.g. "2026-03"
+} & Model
+```
+
+Your application sets `touchedAt` on every write (including its own updates) and sets `deletedAt` when it removes a document. `msync` does the same on the documents it creates. Bump `touchedAt` with the cluster time; streams resume from it.
+
+Derived fields use a leading `_`. That is how a downstream stream knows the field is produced by an upstream one and should be waited for. Pass `needs: { plainField: 1 }` to wait on a field that does not use the prefix, or `needs: { _alreadyThere: 0 }` to read a `_` field without waiting.
+
+## The shape of every stream
+
+```ts
+staging(view, 'unique-stream-name')
+  .with($lookup({ /* join, needs the left-hand stream */ }))
+  .then($replaceWith(/* reshape the current document */))
+  .then($match(/* keep or drop */))
+  .get()          // freeze the pipeline; also what $lookup expects as `from`
+  .out($merge(/* ... */)(/* write */))
+```
+
+- `.with(fn)` wraps the stream so far. `$lookup` and `$outerLookup` are written this way, because a join has to see the left side.
+- `.then(stage)` appends a stage that only sees the current document: `$set`, `$replaceWith`, `$match`, `$unwind`.
+- `.get()` closes the pipeline.
+- `.out(sink)` attaches the writer and returns a runner.
+
+`from` has the same chain, and its stages are linear (`$set`, `$replaceWith`, `$match`). It has no snapshot, so it has no `$lookup`.
+
+A projection entry is a pair, `[fieldName, 1]`, under the same name:
+
+```ts
+projection: {
+  createdAt: ['createdAt', 1],
+  regionId: ['regionId', 1],
+}
+```
+
+A field expression is a pair too, `[fieldName, expr]`, inside `field({ ... })` and inside merge and group maps.
+
+```ts
+root<Account>().of('createdAt').expr()   // this document's field
+val(' ')                                  // a literal
+concat(first, val(' '), last)             // an expression
+```
+
+`root<T>()` is the current document, typed as `T`. `.of('key')` steps into a field. `.expr()` turns the path into a value you can pass to `concat`, `$sum`, `$merge`, and the rest.
+
+## Tutorial
+
+One small domain runs through every example: accounts place orders, and plans are sold per region. Each function takes the collections it touches and returns a runner. The runners are what you hand to a `Machine`.
+
+### 1. Derive a field from the document itself
+
+An account has `createdAt`. List pages want the cohort (`YYYY-MM`) without parsing dates on every read. Keep `_cohort` on the account, and refresh it when `createdAt` changes.
+
+`from` is enough: there is no join and no previous value to subtract.
+
+```ts
+import type { Collection, Model, N, O } from '@omegup/msync'
+import { $simpleMerge, from, monthPart, root } from '@omegup/msync'
+
+type Account = O<{
+  _id: string
+  name: string
+  createdAt: Date
+  _cohort: string | N
+}>
+
+export const makeAccountCohortStream = (accounts: Collection<Account & Model>) =>
+  from(
+    {
+      collection: accounts,
+      projection: { createdAt: ['createdAt', 1] },
+    },
+    'account-cohort',
+  )
+    .get()
+    .out(
+      $simpleMerge<O<{ _cohort: string }>>()(accounts, {
+        _cohort: ['_cohort', monthPart(root<Account>().of('createdAt').expr())],
+      }),
+    )
+```
+
+`$simpleMerge` writes `_cohort` onto the same `_id`. The document is already there, so a missing target fails the merge. The next change of `createdAt` rewrites that account only.
+
+```
+{ _id: "a1", createdAt: 2026-03-02 }   →   { _cohort: "2026-03" }
+```
+
+### 2. Copy a field across a reference
+
+An order stores `accountId`. The account stores `name`. Reading an order should not look the account up again, and renaming an account should fix every order that points at it.
+
+This needs `staging`. `$lookup` watches both sides: the order's `accountId`, and the account's `name`.
+
+```ts
+import type { Collection, Model, O, OPick, StrKey } from '@omegup/msync'
+import { $lookup, $merge, root, staging } from '@omegup/msync'
+
+type Account = O<{ _id: string; name: string }>
+type Order = O<{ _id: string; accountId: string; total: number; _accountName?: string }>
+
+type OrderView = OPick<Order & Model, '_id' | 'accountId'>
+type AccountView = OPick<Account & Model, '_id' | 'name'>
+type Joined = OrderView & { readonly account: AccountView }
+
+export const makeOrderAccountNameStream = (
+  orders: Collection<Order & Model>,
+  accounts: Collection<Account & Model>,
+) =>
+  staging<Order & Model, StrKey<OrderView>>(
+    {
+      collection: orders,
+      projection: { accountId: ['accountId', 1] },
+    },
+    'order-account-name',
+  )
+    .with(
+      $lookup({
+        as: 'account',
+        to: 'one',
+        from: staging(
+          {
+            collection: accounts,
+            projection: { name: ['name', 1] },
+          },
+          'accounts-for-orders',
+        ).get(),
+        localField: root<OrderView>().of('accountId'),
+      }),
+    )
+    .get()
+    .out(
+      $merge<O<{ _accountName: string }>>()(orders, {
+        _accountName: ['_accountName', root<Joined>().of('account').of('name').expr()],
+      }),
+    )
+```
+
+The inner `staging(...).get()` is a stream of its own, with its own snapshot. `$merge` patches `_accountName` back onto the order. A later stream that projects `_accountName` waits until this one has written it.
+
+`$lookup` keeps documents that match. `$outerLookup` keeps the left document when the right side is missing, and types the joined field as `T | null`.
+
+A lookup says where it points with `to`. `to: 'one'` means `localField` points at the right document's `_id`, so there is no `foreignField`. Each left row matches one right row, and the result keeps the left `_id`. `to: 'many'` is several matches per left row, or a join on some other field: pass `middle` and both fields. The lookup writes each row's `_id` as the left id, that string, and the right id. You do not build that id again afterwards.
+
+### 3. Keep a total on the parent
+
+Each order has an `accountId` and a `total`. The account should store `_lifetimeSpend`, the sum of its orders, including orders that change or disappear.
+
+`$groupId` folds into a document that already exists. The group key is that document's `_id`, here the account id. `$sum` is delta-aware: a new order adds its total, an edited order subtracts the old total and adds the new one, a deleted order subtracts. The account is never recomputed from scratch.
+
+```ts
+import type { Collection, Model, O } from '@omegup/msync'
+import { $groupId, $sum, notNull, root, staging } from '@omegup/msync'
+
+type Account = O<{ _id: string; _lifetimeSpend?: number }>
+type Order = O<{ _id: string; accountId: string; total: number }>
+
+export const makeAccountSpendStream = (
+  orders: Collection<Order & Model>,
+  accounts: Collection<Account & Model>,
+) =>
+  staging<Order & Model, '_id' | 'accountId' | 'total'>(
+    {
+      collection: orders,
+      projection: {
+        accountId: ['accountId', 1],
+        total: ['total', 1],
+      },
+      match: notNull(root<Order>().of('accountId').expr()),
+    },
+    'account-lifetime-spend',
+  )
+    .get()
+    .out(
+      $groupId<Order, O<{ _lifetimeSpend: number }>, {}, Account & Model>(
+        root<Order>().of('accountId').expr(),
+        {
+          _lifetimeSpend: ['_lifetimeSpend', $sum(root<Order>().of('total').expr())],
+        },
+        accounts,
+        {},
+      ),
+    )
+```
+
+Read `$groupId` as four arguments:
+
+1. The group key, a string expression. It must equal `_id` on the target.
+2. Accumulators. Each value is `['field', accumulator]`. These fields are maintained incrementally on the target.
+3. The target collection.
+4. Extra fields, recomputed from the accumulator output on every update. `{}` when the accumulator value is already what you want to store.
+
+`$group` is the same fold when the target document does not exist yet. It stores the key in `_grp` and inserts. Use it for a summary collection, such as revenue per month. Use `$groupId` to hang a summary on a document you already have, such as spend on an account.
+
+When the thing you are counting is a set of strings rather than a number, use `$countDict`. It stores a map of string to count, drops keys whose count falls to zero, and pairs with `$keys` in the extra-fields argument to publish the surviving strings as an array. A product that references tag ids, joined to the tag's name and folded with `$countDict`, keeps `_tags` on the product this way. The [guide](docs/guide.md) shows that accumulator next to `$sum`.
+
+### 4. Materialize a collection of pairs
+
+Plans are sold per region. Every account in a region is entitled to every plan in that region. Each pair is its own document in `entitlements`, with `_id` of `accountId-planId`, so other streams can aggregate entitlements directly. When the plan's price changes, the entitlement updates. When the account or the plan goes away, the entitlement is soft-deleted.
+
+Several plans can share a region, so this lookup is `to: 'many'`. `middle: '-'` is required, and the lookup sets each row's `_id` to the account id, that hyphen, and the plan id. Copy `accountId` off `_id` before the join, because the composite id replaces it. `$replaceWith` keeps the id the lookup already assigned. `$insert` upserts by that `_id`, and on a deleted input it sets `deletedAt`.
+
+```ts
+import type { Collection, ID, Model, O, OPick } from '@omegup/msync'
+import { $insert, $lookup, $replaceWith, $set, field, root, staging, to } from '@omegup/msync'
+
+type Account = O<{ _id: string; regionId: string }>
+type Plan = O<{ _id: string; regionId: string; price: number }>
+type Entitlement = O<{
+  _id: string
+  accountId: string
+  planId: string
+  price: number
+}>
+
+export const makeEntitlementStream = (
+  accounts: Collection<Account & Model>,
+  plans: Collection<Plan & Model>,
+  entitlements: Collection<Entitlement & Model>,
+) => {
+  type AccountView = OPick<Account & Model, keyof ID | 'regionId'>
+  type PlanView = OPick<Plan & Model, keyof ID | 'regionId' | 'price'>
+  type WithAccountId = AccountView & O<{ accountId: string }>
+  type Joined = WithAccountId & { readonly plan: PlanView }
+
+  return staging<Account & Model, keyof AccountView>(
+    {
+      collection: accounts,
+      projection: { regionId: ['regionId', 1] },
+    },
+    'entitlements-from-accounts',
+  )
+    .then(
+      $set<O<{ accountId: string }>>()({
+        accountId: ['accountId', to(root<AccountView>().of('_id').expr())],
+      }),
+    )
+    .with(
+      $lookup({
+        as: 'plan',
+        to: 'many',
+        middle: '-',
+        from: staging(
+          {
+            collection: plans,
+            projection: {
+              regionId: ['regionId', 1],
+              price: ['price', 1],
+            },
+          },
+          'plans-for-entitlements',
+        ).get(),
+        localField: root<WithAccountId>().of('regionId'),
+        foreignField: root<PlanView>().of('regionId'),
+      }),
+    )
+    .then(
+      $replaceWith(
+        field<Entitlement, Joined>({
+          _id: ['_id', root<Joined>().of('_id').expr()],
+          accountId: ['accountId', root<Joined>().of('accountId').expr()],
+          planId: ['planId', root<Joined>().of('plan').of('_id').expr()],
+          price: ['price', root<Joined>().of('plan').of('price').expr()],
+        }),
+      ),
+    )
+    .get()
+    .out($insert(entitlements))
+}
+```
+
+The same account and the same plan always produce the same `_id`, because `middle` is part of the lookup. That is how the next run finds the row to update or retire.
+
+## Run them together
+
+A `Machine` merges runners and loops. Each tick reports which stream did the work.
+
+```ts
+import { Machine, prepare } from '@omegup/msync'
+
+const client = await prepare() // connects with MONGO_URL, or use your own MongoClient
+const db = client.db(process.env.MONGO_NAME)
+
+const accounts = db.collection('accounts')
+const orders = db.collection('orders')
+const plans = db.collection('plans')
+const entitlements = db.collection('entitlements')
+
+const machine = new Machine()
+machine.add(makeAccountCohortStream(accounts))
+machine.add(makeOrderAccountNameStream(orders, accounts))
+machine.add(makeAccountSpendStream(orders, accounts))
+machine.add(makeEntitlementStream(accounts, plans, entitlements))
+
+await machine.start(info => {
+  console.log(new Date(), info.debug)
+})
+```
+
+`.start` resolves only when it stops. Return `true` from the callback to stop after the current tick. Add streams in an order you can read — producers of `_` fields before the streams that project them — then let the machine run them side by side. The `_` prefix (and `needs`) is what makes a consumer skip a document until the producer has filled it.
+
+Stream names are unique inside the process. Reusing a name from two different call sites throws. Pick a name that says what the stream maintains: `'account-cohort'`, `'order-account-name'`.
+
+Split a large sync by area. Each area builds a `Machine` and returns it. The process adds every area and starts once:
+
+```ts
+const machine = new Machine()
+machine.add(billing(client).runner())
+machine.add(catalog(client).runner())
+await machine.start(info => {
+  console.log(new Date(), info.debug)
+})
+```
+
+## Next
+
+[docs/guide.md](docs/guide.md) is the rest of the language: expressions, predicates, accumulators, the write modes side by side, and what the process stores while it runs.

package/package.json

@@ -1,9 +1,18 @@
 {
+    "name": "@omegup/msync",
+    "version": "0.1.57",
+    "description": "Keeps derived MongoDB data in sync with the documents it comes from.",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Omegup/msync.git"
+    },
+    "homepage": "https://omegup.github.io/msync/",
+    "bugs": {
+        "url": "https://github.com/Omegup/msync/issues"
+    },
     "main": "index.js",
     "module": "index.esm.js",
     "typings": "index.d.ts",
-    "name": "@omegup/msync",
-    "version": "0.1.55",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",

package/lib/accumulators/index.d.ts

@@ -1,28 +0,0 @@
-import type { AppMap, N, O, PRRec } from '../../types';
-import type { ExprHKT } from '../expression/concat';
-import { type AddO } from '../expression/val';
-import type { DeltaAccumulator, Expr, Part } from '../types';
-type AddOs<A extends readonly unknown[]> = {
-    [K in keyof A]: AddO<A[K]>;
-};
-type PushSides<V> = {
-    0: V[];
-    1: V[];
-};
-type PushDict<V> = PRRec<string, PushSides<V>>;
-export declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
-export declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => T, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, AddOs<A>>, accumulate: (a: T, ...args: A) => T, merge: (...args: [T | N, T]) => T) => DeltaAccumulator<D, AddO<T>, Ctx>;
-export declare const $countDict: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
-export declare const $countDictArray: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K[]>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
-export declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<AddO<V>, D, C>) => DeltaAccumulator<D, O<{
-    [x: string]: O<{
-        0: import("../..").Arr<AddO<V>>;
-        1: import("../..").Arr<AddO<V>>;
-    }> | undefined;
-}>, C>;
-export declare const $keys: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<PRRec<K, number>>, D, C>) => Expr<AddO<K[]>, D, C>;
-export declare const $entries: <D extends O, V, C = unknown>(expr: Expr<AddO<PushDict<V>>, D, C>) => Expr<AddO<{
-    k: string;
-    v: V;
-}[]>, D, C>;
-export {};

package/lib/aggregate/$merge.d.ts

@@ -1,37 +0,0 @@
-import type { IdHKT, OPick, RWCollection, Timestamp } from '../../types';
-import type { doc, ID, N, O, rawItem, Rec, Replace, RORec, StrKey } from '../../types/json';
-import { type ExprsExact } from '../expression/concat';
-import type { Delta, Expr, IsDeleted, Model, RawStages, StreamRunnerParam, TS } from '../types';
-import { type Exact } from '../utils/map-object';
-type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
-type Allowed<K extends string> = Exclude<K, keyof (TS & ID)>;
-export type Patch<V, KK extends StrKey<V> = StrKey<V>> = ((OPick<V, Allowed<KK>> & ID) | (Rec<Allowed<KK>, N> & ID)) & TS;
-type TakeDoc<V, E = ID, KK extends StrKey<V> = StrKey<V>> = OPick<V, Allowed<KK>> & E;
-type ND = {
-    readonly deletedAt?: null;
-};
-type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
-type Args<P, Out> = [added: Expr<P, unknown, {
-    new: P;
-}>, old: Expr<Out, Out>];
-type Result<P> = Expr<P, unknown, {
-    new: P;
-}>;
-type Update<P, Out> = (...args: Args<P, Out>) => Result<P>;
-type UpdateF<P, Out> = <K extends keyof IsDeleted>(...args: Args<Replace<P, RORec<K, Timestamp>>, Out>) => Result<Replace<P, RORec<K, Timestamp>>>;
-export declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert", update: Update<Replace<P, RORec<K, Timestamp>>, Out>) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
-export declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Rec<"old" | "merged", Out | Replace<Out, P>>, Out | Replace<Out, P>>;
-type MergeCollection<V extends O, Out extends Model> = {
-    coll: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>;
-    whenNotMatched: 'discard';
-} | {
-    coll: RWCollection<Out | Replace<Out, Patch<V>>, Out>;
-    whenNotMatched: 'fail';
-};
-type MergeUpdate<V, Out> = UpdateF<((OPick<V, Allowed<StrKey<V>>> & ID) | (Rec<Allowed<StrKey<V>>, N> & ID)) & TS, Out>;
-export declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends Model, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, id: Expr<string, OutInputE<TakeDoc<V>, E, null>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
-export declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends Model, EEE extends RORec<string, rawItem>>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Source, "out">;
-export declare const $simpleMerge: <V extends O>() => <Source extends doc, Out extends Model>(out: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard", update?: MergeUpdate<V, Out>) => StreamRunnerParam<Source, "out">;
-export declare const $mergePart: <V extends O>() => <Out extends Model, SourcePart extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-export declare const $merge: <V extends O>() => <Out extends Model, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-export {};

package/lib/aggregate/$upsert.d.ts

@@ -1,19 +0,0 @@
-import type { IdHKT, Replace, RWCollection } from '../../types';
-import type { ID, O, RORec, doc, rawItem } from '../../types/json';
-import { type ExprsExact } from '../expression/concat';
-import type { Del, Delta, Expr, StreamRunnerParam, TS } from '../types';
-import { type Exact } from '../utils/map-object';
-type ND = {
-    readonly deletedAt?: null;
-};
-type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
-export type Merge<T extends doc, E> = Omit<SafeE<E>, keyof (ND & TS)> & ((T & ND & TS) | Del);
-type ExprP<P> = Expr<P, unknown, {
-    new: P;
-}>;
-type Update<P, Out> = (added: ExprP<P>, old: Expr<Out, Out>) => ExprP<P>;
-export declare const $insertX: <T extends doc, D extends O, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, expr: Expr<T, D>, map: (x: Expr<T & ND & TS & Omit<SafeE<EEE>, keyof (ND & TS)>, D>) => Expr<Merge<T, EEE>, D>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, extExpr: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>, update?: Update<Replace<Merge<T, EEE>, {}>, Merge<T, EEE>>) => StreamRunnerParam<D, "out">;
-export declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
-export declare const $insertPart: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Delta<T>, "out">;
-export declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
-export {};

package/lib/aggregate/group/$group-merge.d.ts

@@ -1,18 +0,0 @@
-import type { RWCollection, WriteonlyCollection } from '../../../types';
-import type { AsLiteral, ID, O, Rec, doc, notArr } from '../../../types/json';
-import { type ExprsExact } from '../../expression/concat';
-import type { Delta, DeltaAccumulators, Expr, StreamRunnerParam, TS } from '../../types';
-import type { MergeInto } from '../out';
-import { type Extra, type IdAndTsKeys, type Loose, type MergedInput, type Strict, type V_Grp } from './utils/sub-merge';
-type Denied<GID = never> = keyof (TS & ID) | GID;
-type GI<GG> = Exclude<GG, keyof TS>;
-export type GroupMergeOut<Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>> = MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, V, Grp, GG, EE>>>;
-export type GroupMergeCollection<WhenNotMatched extends MergeInto<never, never>['whenNotMatched'], Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>> = (GroupMergeOut<Grp, V, GG, EE, Out> & {
-    whenNotMatched: WhenNotMatched;
-})['into'];
-export declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: GroupMergeOut<Grp, V, GG, EE, Out>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
-export type GroupIdCollection<V extends O, EE = {}, Out extends Loose<string, V, '_id'> = Loose<string, V, '_id'>> = RWCollection<MergedInput<Out, V, string, '_id', EE>, Out>;
-export declare const $groupId: <T extends O, V extends O, EE = {}, Out extends Loose<string, V, "_id"> = Loose<string, V, "_id">>(id: Expr<string, T>, args: DeltaAccumulators<T, O & Omit<V, Denied>>, out: GroupIdCollection<V, EE, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<Delta<T>, "out">;
-export type GroupCollection<Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, '_grp'> = Loose<Grp, V, '_grp'>> = RWCollection<MergedInput<Out, V, Grp, '_grp', EE> | Strict<Grp, V, '_grp', EE>, Out>;
-export declare const $group: <T extends O, Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, "_grp"> = Loose<Grp, V, "_grp">>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<"_grp">>>, out: GroupCollection<Grp, V, EE, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | Exclude<keyof V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
-export {};

package/lib/aggregate/group/index.d.ts

@@ -1,3 +0,0 @@
-export { $groupMerge, $groupId, $group } from './$group-merge';
-export type { GroupCollection, GroupIdCollection, GroupMergeCollection } from './$group-merge';
-export type { Loose, Strict, MergedInput } from './utils/sub-merge';

package/lib/aggregate/group/utils/sub-group.d.ts

@@ -1,6 +0,0 @@
-import type { O, RORec, Rec } from '../../../../types';
-import { type ExprsExact } from '../../../expression/concat';
-import type { Delta, Expr, RawStages } from '../../../types';
-import type { DeltaAccumulators } from '../../../types/accumulator';
-export type WithItem<V, Grp> = Rec<'_id', Grp> & Rec<'item', O<V>>;
-export declare const subGroup: <T extends O, Grp, V extends O, GID extends string>(id: Expr<Grp, T>, args: DeltaAccumulators<T, V>, addGrp: <D extends Rec<"_id", Grp>>(src: ExprsExact<V, D>) => ExprsExact<RORec<GID, Grp> & V, D>) => RawStages<unknown, Delta<T>, Rec<GID, Grp> & V>;

package/lib/aggregate/group/utils/sub-merge.d.ts

@@ -1,20 +0,0 @@
-import type { AsLiteral, ID, O, Rec, Replace, WriteonlyCollection, notArr } from '../../../../types';
-import { type ExprsExact } from '../../../expression/concat';
-import type { Model, RawStages, TS } from '../../../types';
-import type { DeltaAccumulators } from '../../../types/accumulator';
-import { type MergeInto } from '../../out';
-type GI<GG> = Exclude<GG, keyof TS>;
-export type IdAndTsKeys = keyof (TS & ID);
-type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI<GG>>;
-export type Prepare<Grp, GG extends string> = TS & ID & Rec<GI<GG>, Grp>;
-type Par<T> = {
-    [P in keyof T]?: T[P] | null;
-};
-export type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
-export type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
-export type V_Grp<VV, GG extends string, Grp> = Rec<GI<GG>, Grp> & V<VV, GG>;
-export type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
-type OrReplace<T, V> = T | Replace<T, V>;
-export type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, VV, GG>>;
-export declare const subMerge: <T extends O, Grp extends notArr, VV extends O, GG extends string, EE = {}, Out extends Loose<Grp, VV, GG> = Loose<Grp, VV, GG>>(args: DeltaAccumulators<T, V<VV, GG>>, out: MergeInto<Strict<Grp, VV, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, VV, Grp, GG, EE>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, VV, GG>, V_Grp<VV, GG, Grp>>, idPrefix: string, first: boolean) => RawStages<unknown, V_Grp<VV, GG, Grp>, "out">;
-export {};

package/lib/aggregate/index.d.ts

@@ -1,10 +0,0 @@
-export { emptyDelta } from './prefix';
-export * from './group';
-export * from './lookup';
-export * from './match';
-export * from './set';
-export * from './unwind';
-export * from './$merge';
-export * from './$upsert';
-export * from './out';
-export { $group_ } from './mongo-stages';

package/lib/aggregate/lookup/$lookup-delta.d.ts

@@ -1,11 +0,0 @@
-import type { Arr, AsLiteral, ID, N, O, Rec, doc, rawItem } from '../../../types';
-import { Field } from '../../field';
-import type { BA, Before, Delta, RawStages, TStages, UBefore } from '../../types';
-import { type JoinId } from '../unwind';
-type s = string;
-type Both<K1 extends s, LE, KK2 extends s, RE, N1 extends null = never, N2 extends null = never> = Delta<Rec<K1, LE | N1> & Rec<Exclude<KK2, BA | K1>, RE | N2> & ID>;
-export declare const $lookupDelta: <LQ extends O, LE extends LQ & doc, RQ extends O, RE extends RQ & doc, BRB extends UBefore<RQ>, RS extends UBefore<RQ>, S extends rawItem, K1 extends s, KK2 extends s, N1 extends null = never, N2 extends null = never>({ field1, field2 }: {
-    field1: Field<LQ, S | N | Arr<S>>;
-    field2: Field<RQ, S | N | Arr<S>>;
-}, { coll, exec, input }: TStages<RS, UBefore<RQ>, BRB, Before<RE>>, k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, BA | K1>>, k: JoinId<K1, Exclude<KK2, BA | K1>>, includeNull1?: N1, includeNull2?: N2) => RawStages<unknown, Delta<LE>, Both<K1, LE, KK2, RE, N1, N2>>;
-export {};

package/lib/aggregate/lookup/$lookup-raw.d.ts

@@ -1,10 +0,0 @@
-import type { App, Arr, AsLiteral, HKT, ID, O, Rec, rawItem } from '../../../types';
-import { type Field } from '../../field';
-import type { Before, RawStages, TStages, UBefore } from '../../types';
-import { type JoinId } from '../unwind';
-type s = string;
-export declare const $lookupRaw: <LQ extends O, LE extends LQ & ID, RQ extends O, RE extends RQ & ID, BRB extends Before<RQ>, RS extends UBefore<RQ>, S extends rawItem, As extends s, Null extends null = never>({ field1, field2 }: {
-    field1: Field<LQ, S | Arr<S>>;
-    field2: Field<RQ, S | Arr<S>>;
-}, { coll, exec, input }: TStages<RS, Before<RQ>, BRB, Before<RE>>, k2: AsLiteral<As>, k: JoinId<"left", "right">, includeNull?: Null) => <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, LQ>, App<F, LE>, App<F, LE & Rec<As, RE | Null> & ID>>;
-export {};

package/lib/aggregate/lookup/index.d.ts

@@ -1,20 +0,0 @@
-import { type AsLiteral, type O, type RORec, type doc, type notArr, type Arr, type N } from '../../../types';
-import { type Field } from '../../field';
-import type { SnapshotStream, SnapshotStreamExecutionResult } from '../../types/stream';
-type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
-    from: SnapshotStreamExecutionResult<RQ, RE>;
-    as: AsLiteral<As>;
-} & ({
-    to: 'one';
-    localField: Field<LQ, string | N>;
-    foreignField?: never;
-    middle?: never;
-} | {
-    to: 'many';
-    middle: string;
-    localField: Field<LQ, S | Arr<S>>;
-    foreignField: Field<RQ, S | Arr<S>>;
-});
-export declare const $lookup: <As extends string, LQ extends doc, RQ extends doc, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
-export declare const $outerLookup: <As extends string, LQ extends doc, RQ extends doc, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE | null>>;
-export {};

package/lib/aggregate/match/$match-delta.d.ts

@@ -1,4 +0,0 @@
-import type { doc } from '../../../types';
-import type { Delta, Expr, RawStages } from '../../types';
-export declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
-export declare const matchDelta: <D>() => RawStages<unknown, Delta<D | null>, Delta<D>>;

package/lib/aggregate/match/$match.d.ts

@@ -1,3 +0,0 @@
-import type { doc } from '../../../types';
-import type { DeltaStages, Expr } from '../../types';
-export declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;

package/lib/aggregate/match/index.d.ts

@@ -1,2 +0,0 @@
-export { $matchDelta, matchDelta } from './$match-delta';
-export { $match } from './$match';

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

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