@omegup/msync 0.1.62 → 0.1.63

package/lib/accumulators/index.d.ts

@@ -18,7 +18,7 @@ export declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string,
     [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<{

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

@@ -19,9 +19,9 @@ type Result<P> = Expr<P, unknown, {
 }>;
 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 getSubsetMatchForExt: <Out extends Model, P extends Model, E extends Record<keyof E, rawItem>>(ext: Exact<E, IdHKT>) => null | Expr<boolean, Rec<'old' | 'merged', Out | Replace<Out, P>>>;
-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>, canWrite: Expr<boolean, Rec<'old' | 'merged', Out | Replace<Out, P>>> | null) => RawStages<O, Out, Out | Replace<Out, P>, RORec<'new', Replace<P, RORec<K, Timestamp>>>>;
-export declare const getWhenMatched: <Out extends Model, P extends Model>(whenNotMatched: 'discard' | 'fail' | 'insert', canWrite: Expr<boolean, Rec<'old' | 'merged', Out | Replace<Out, P>>> | null) => RawStages<O, Rec<'old' | 'merged', Out | Replace<Out, P>>, Out | Replace<Out, P>>;
+export declare const getSubsetMatchForExt: <Out extends Model, P extends O & ID & TS, E extends Record<keyof E, rawItem>>(ext: Exact<E, IdHKT>) => null | Expr<boolean, Rec<'old' | 'merged', Out | Replace<Out, P>>>;
+export declare const getWhenMatchedForMerge: <Out extends Model, P extends O & ID & TS, K extends keyof IsDeleted>(whenNotMatched: 'discard' | 'fail' | 'insert', update: Update<Replace<P, RORec<K, Timestamp>>, Out>, canWrite: Expr<boolean, Rec<'old' | 'merged', Out | Replace<Out, P>>> | null) => RawStages<O, Out, Out | Replace<Out, P>, RORec<'new', Replace<P, RORec<K, Timestamp>>>>;
+export declare const getWhenMatched: <Out extends Model, P extends O & ID & TS>(whenNotMatched: 'discard' | 'fail' | 'insert', canWrite: Expr<boolean, Rec<'old' | 'merged', Out | Replace<Out, P>>> | null) => 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';
@@ -30,9 +30,9 @@ type MergeCollection<V extends O, Out extends Model> = {
     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 { [K in StrKey<EEE>]: 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 $mergeId: <V extends O>() => <SourcePart extends doc, Out extends Model, E = unknown, EEE extends { [K in keyof EEE]: 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 { [K in StrKey<EEE>]: 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 { [K in StrKey<EEE>]: 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 $mergePart: <V extends O>() => <Out extends Model, SourcePart extends doc, EEE extends { [K in keyof EEE]: 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/group/utils/sub-merge.d.ts

@@ -1,6 +1,6 @@
 import type { AsLiteral, ID, O, RWCollection, Rec, Replace, notArr, Omit, Exclude } from '../../../../types';
 import { type ExprsExact } from '../../../expression/concat';
-import type { IsDeleted, Model, RawStages, TS } from '../../../types';
+import type { DeletedAt, IsDeleted, Model, RawStages, TS } from '../../../types';
 import type { DeltaAccumulators } from '../../../types/accumulator';
 type GI<GG> = Exclude<GG, keyof TS>;
 export type IdAndTsKeys = keyof (TS & ID);
@@ -9,7 +9,7 @@ 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 Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>> & DeletedAt;
 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>>;

package/lib/aggregate/prefix.d.ts

@@ -1,8 +1,8 @@
-import type { App, HKT, O2, O3, O, RawObj } from '../../types';
+import type { App, HKT, O2, O3, O } from '../../types';
 import type { Delta, DeltaStages, FRawStages, RawStages, Stream, TStages } from '../types';
 import type { Equal } from '../utils/guard';
 type n = number;
-export declare const asStages: <Q, T extends Q, V extends Q, C = unknown, M extends n = n>(x: readonly RawObj[]) => RawStages<Q, T, V, C, M>;
+export declare const asStages: <Q, T extends Q, V extends Q, C = unknown, M extends n = n>(x: RawStages<Q, T, V, C, M>) => RawStages<Q, T, V, C, M>;
 export declare const same: <T extends Dom, V extends Dom, F extends HKT<Dom, Q>, Dom = unknown, Q = unknown, C = unknown, M extends n = n>(_: Equal<Dom, T, V>) => RawStages<Q, App<F, T>, App<F, V>, C, M>;
 export declare const concatStages: <Q, T extends Q, V extends Q, W extends Q, C, M extends n = n>(part1: RawStages<Q, T, V, C, M>, part2: RawStages<Q, V, W, C, M>) => RawStages<Q, T, W, C, M>;
 export declare const concatFStages: <Q, T extends Q & O, V extends Q & O, W extends Q & O, C, M extends n = n>(part1: FRawStages<Q, T, V, C, M>, part2: FRawStages<Q, V, W, C, M>) => FRawStages<Q, T, W, C, M>;

package/lib/boot/boot-utils.d.ts

@@ -1,5 +1,4 @@
-import { Collection, type Timestamp } from 'mongodb';
-import type { BSON, Exclude, OPickD, rawItem, RawObj, StrKey } from '../../types';
+import type { Collection, Document, Exclude, OPickD, rawItem, RawObj, StrKey, Timestamp } from '../../types';
 import type { Actions, Model } from '../types/stream';
 export type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
 export type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
@@ -23,5 +22,5 @@ export type Last = {
     job?: 1 | null;
 };
 export declare const actions: {
-    [K in keyof Actions<unknown>]: <W extends BSON.Document>(col: Collection<W>, x: Actions<W>[K]) => [Promise<unknown>, unknown[]];
+    [K in keyof Actions<unknown>]: <W extends Document>(col: Collection<W>, x: Actions<W>[K]) => [Promise<unknown>, unknown[]];
 };

package/lib/boot/boot.d.ts

@@ -1,10 +1,10 @@
-import type { O2, O3, StrKey, View } from '../../types';
+import type { Dict, O2, O3, StrKey, View } from '../../types';
 import type { HKT, I } from '../../types/hkt';
 import { type DeltaPipe } from '../aggregate/prefix';
 import type { SnapshotStreamExecutionResult } from '../types';
 import type { DeltaStages, Model } from '../types/stream';
 import type { Allowed, AllowedPick } from './boot-utils';
-export declare const streamNames: Record<string, string>;
+export declare const streamNames: Dict<string>;
 export interface SnapshotStreamHKT extends HKT<O2> {
     readonly out: SnapshotStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
 }

package/lib/boot/first-stages.d.ts

@@ -1,5 +1,4 @@
-import { Timestamp } from 'mongodb';
-import type { O, StrKey, View } from '../../types';
+import type { O, StrKey, Timestamp, View } from '../../types';
 import { type Concat } from '../aggregate/prefix';
 import type { Query } from '../types';
 import type { Del, Model } from '../types/stream';

package/lib/driver.d.ts

@@ -0,0 +1,5 @@
+import type { Driver } from '../types';
+export type { Driver } from '../types';
+export declare const useDriver: (driver: Driver) => void;
+export declare const driver: () => Driver;
+export declare const uuid: () => string;

package/lib/expression/val.d.ts

@@ -1,4 +1,4 @@
-import type { Timestamp } from 'mongodb';
+import type { Timestamp } from '../../types';
 import type { Arr, N, O, StrKey, jsonItem, notObj, rawItem } from '../../types';
 import type { Expr } from '../types';
 import type { ExprsExact } from './concat';

package/lib/predicate/$eq.d.ts

@@ -1,5 +1,4 @@
-import type { Timestamp } from 'mongodb';
-import type { Arr, N, rawItem, RawObj } from '../../types';
+import type { Arr, N, rawItem, RawObj, Timestamp } from '../../types';
 export declare const $eq: <T extends unknown>(operand: rawItem & T) => import("../types").Predicate<T>;
 export declare const $ne: <T extends unknown>(operand: rawItem & T) => import("../types").Predicate<T>;
 type Numeric = number | Timestamp | Date;

package/lib/types/accumulator.d.ts

@@ -1,5 +1,5 @@
 import type { Expr } from './expr';
-import type { HKT, I, N, O, RORec, RawObj, Rec, Type, U, Undef, jsonItem } from '../../types';
+import type { HKT, I, N, O, PRRec, RORec, RawObj, Rec, Type, U, Undef, jsonItem } from '../../types';
 import type { Field } from '../field';
 import type { Exact } from '../utils/map-object';
 declare const AccumulatorRaw: unique symbol;
@@ -15,7 +15,7 @@ export interface DeltaAccumulatorHKT<T, C = unknown> extends HKT<unknown> {
     readonly out: DeltaAccumulator<T, I<unknown, this>, C>;
 }
 export type DeltaAccumulators<T, V extends object, C = unknown> = Exact<V, DeltaAccumulatorHKT<T, C>>;
-export type AccumulatorsRoot<Acc extends Accumulators<never, RORec<string, jsonItem>, never>> = Acc extends Accumulators<infer T extends O, RORec<string, jsonItem>, never> ? T : never;
+export type AccumulatorsRoot<Acc extends Accumulators<never, PRRec<string, jsonItem>, never>> = Acc extends Accumulators<infer T extends O, PRRec<string, jsonItem>, never> ? T : never;
 export type Accumulator<in Doc, out T, in Ctx = unknown> = {
     [Type]?(_: typeof Accumulator): typeof Accumulator;
     raw: {

package/lib/types/aggregate.d.ts

@@ -1,7 +1,9 @@
-import type { Long, Timestamp } from 'mongodb';
+import type { Timestamp } from '../../types';
 export type AggregateCommand<T> = {
     cursor: {
-        id: Long | number;
+        id: number | {
+            toString(): string;
+        };
         firstBatch: T[];
         atClusterTime: Timestamp;
         ns: string;

package/lib/types/query.d.ts

@@ -1,12 +1,8 @@
 import type { O, RawObj, Type } from '../../types';
 import type { Field } from '../field';
 declare const Query: unique symbol;
-declare const QueryRaw: unique symbol;
-export type QueryRaw<T, C = unknown> = RawObj & {
-    [Type]?(x: typeof QueryRaw, y: T, c: C): void;
-};
 export type Query<in T extends O, in C = unknown> = {
     [Type]?(x: typeof Query, y: T, c: C): void;
-    raw: <DeltaT extends O>(f: Field<DeltaT, T>) => QueryRaw<DeltaT, C>;
+    raw: <DeltaT extends O>(f: Field<DeltaT, T>) => RawObj;
 };
 export {};

package/lib/types/stream.d.ts

@@ -1,5 +1,4 @@
-import type { BSON, Filter, Timestamp, UpdateFilter } from 'mongodb';
-import type { App, HKT, ID, N, O, RawObj, ReadonlyCollection, Rec, Type, WriteonlyCollection } from '../../types';
+import type { App, Document, Timestamp, HKT, ID, N, O, RawObj, ReadonlyCollection, Rec, Type, WriteonlyCollection } from '../../types';
 import type { Field } from '../field';
 import type { HasJob, Runner } from './machine';
 declare const RawStage: unique symbol;
@@ -22,8 +21,8 @@ export type TStages<in out S, out Q, in out B extends Q, out R extends Q, M exte
 };
 export type Stages<out Q, out R extends Q, out SDom> = <E>(consume: <S extends SDom, B extends Q>(value: TStages<S, Q, B, R>) => E) => E;
 export type Actions<W> = {
-    updateMany: [Filter<W>, UpdateFilter<W> | BSON.Document[]];
-    deleteMany: [Filter<W>];
+    updateMany: [Document, Document | readonly Document[]];
+    deleteMany: [Document];
 };
 export type TeardownRecord<W, M extends keyof Actions<W>> = {
     collection: WriteonlyCollection<W>;

package/lib/utils/db-indexes.d.ts

@@ -1,4 +1,4 @@
-import type { Collection, CreateIndexesOptions, Db, IndexSpecification } from 'mongodb';
+import type { Collection, CreateIndexesOptions, Db, IndexSpecification } from '../../types';
 export declare const indexMap: Map<string, Map<string, Promise<void>>>;
 export declare const createIndex: (collection: {
     readonly createIndex: Collection['createIndex'];

package/lib/utils/map-object.d.ts

@@ -1,13 +1,9 @@
 import type { App, HKT, I, IdHKT, Omit, RORec, StrKey } from '../../types';
-export declare const map: <T, K extends string & keyof T, V extends RORec<K, unknown>>(x: Pick<T, K>, f: <P extends K>(v: T[P], k: P) => V[P]) => V;
 export type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
 export type ExactPart1<T, F extends HKT<StrKey<T>>> = {
     readonly [K in StrKey<T>]: App<F, K>;
 };
 type s = string;
-export type MapKDom<RK extends MapKDom<RK, F>, F extends HKT<StrKey<RK>>> = MapO<RK, F> & {
-    readonly [P in s]?: readonly [keyof RK, unknown];
-};
 export type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
 export type MapO<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = MapOPart<T, F, K> & {
     readonly [P: string]: readonly [K, unknown];

package/lib/utils/merge/merge.d.ts

@@ -1,10 +1,11 @@
+import type { PRRec } from '../../../types';
 import type { Frame, IteratorResult, HasJob } from '../../types';
 import type { KEYS, Race, SourceIteratorResults, SourceResults } from './types';
-export declare const mergeIterators: <K extends KEYS, Result, Info extends Record<K, HasJob>>(params: {
+export declare const mergeIterators: <K extends KEYS, Result, Info extends PRRec<K, HasJob>>(params: {
     sources: SourceIteratorResults<K, Result, Info>;
-    interrupt?: (key: KEYS) => boolean;
-    select?: Race<K, Result, Info>;
+    interrupt?: ((key: KEYS) => boolean) | undefined;
+    select?: Race<K, Result, Info> | undefined;
     hooks?: {
         start?: (frame: Frame<Result, Info[K]>, result: IteratorResult<Result, Info[K]>) => void;
-    };
+    } | undefined;
 }) => IteratorResult<Result, SourceResults<K, Info>>;

package/lib/utils/merge/next-winner.d.ts

@@ -1,3 +1,4 @@
+import type { PRRec } from '../../../types';
 import type { NextFrame, HasJob } from '../../types';
 import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
-export declare const nextWinner: <K extends KEYS, Result, Info extends Record<K, HasJob>>(previousWinner: RaceWinner<K, Result, Info>, previousWinnerNextFrame: NextFrame<Result, Info[K]>, sources: SourceIteratorResults<K, Result, Info>, interrupt?: (key: KEYS) => boolean) => PromiseLike<RaceWinner<K, Result, Info>>;
+export declare const nextWinner: <K extends KEYS, Result, Info extends PRRec<K, HasJob>>(previousWinner: RaceWinner<K, Result, Info>, previousWinnerNextFrame: NextFrame<Result, Info[K]>, sources: SourceIteratorResults<K, Result, Info>, interrupt?: (key: KEYS) => boolean) => PromiseLike<RaceWinner<K, Result, Info>>;

package/lib/utils/merge/types.d.ts

@@ -1,19 +1,23 @@
+import type { PRRec } from '../../../types';
 import type { Frame, IteratorResult, HasJob } from '../../types';
 export type KEYS = string;
-export type SourceIteratorResults<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+export type SourceIteratorResults<K extends KEYS, Result, Info extends PRRec<K, unknown>> = {
+    readonly [P in K]?: IteratorResult<Result, Info[P]>;
+};
+export type RSourceIteratorResults<K extends KEYS, Result, Info extends PRRec<K, unknown>> = {
     readonly [P in K]: IteratorResult<Result, Info[P]>;
 };
-export type SourceResults<K extends KEYS, Info extends Record<K, HasJob>> = {
+export type SourceResults<K extends KEYS, Info extends PRRec<K, HasJob>> = {
     readonly [P in K]: {
         readonly key: P;
         readonly value: Info[P];
-        readonly job: Info[P]['job'];
+        readonly job: (Info[P] & {})['job'];
     };
 }[K];
-export type RaceWinner<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+export type RaceWinner<K extends KEYS, Result, Info extends PRRec<K, unknown>> = {
     readonly [P in K]: {
         readonly key: P;
         readonly frame: Frame<Result, Info[P]>;
     };
 }[K];
-export type Race<K extends KEYS, Result, Info extends Record<K, HasJob>> = (arg: SourceIteratorResults<K, Result, Info>) => PromiseLike<RaceWinner<K, Result, Info>>;
+export type Race<K extends KEYS, Result, Info extends PRRec<K, HasJob>> = (arg: SourceIteratorResults<K, Result, Info>) => PromiseLike<RaceWinner<K, Result, Info>>;

package/lib/utils/merge/utils.d.ts

@@ -1,4 +1,6 @@
+import type { PRRec } from '../../../types';
 import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
+export declare const map: <T, K extends string & keyof T & keyof V, V>(x: Pick<T, K>, f: <P extends K>(v: Required<T>[P], k: P) => V[P]) => V;
 export declare const patch: <T, K extends keyof T>({ ...x }: T, k: K, v: T[K]) => T;
-export declare const restart: <K extends KEYS, Result, Info extends Record<K, unknown>>(sources: SourceIteratorResults<K, Result, Info>) => SourceIteratorResults<K, Result, Info>;
-export declare const race: <W, K extends KEYS, Result, Info extends Record<K, W>>(sources: SourceIteratorResults<K, Result, Info>) => Promise<RaceWinner<K, Result, Info>>;
+export declare const restart: <K extends KEYS, Result, Info extends PRRec<K, unknown>>(sources: SourceIteratorResults<K, Result, Info>) => SourceIteratorResults<K, Result, Info>;
+export declare const race: <W, K extends KEYS, Result, Info extends PRRec<K, W>>(sources: SourceIteratorResults<K, Result, Info>) => Promise<RaceWinner<K, Result, Info>>;

package/lib/watch.d.ts

@@ -1,12 +1,11 @@
-import { type Db, Timestamp } from 'mongodb';
-import type { O, StrKey, View } from '../types';
+import type { Db, Dict, Document, O, StrKey, Timestamp, View } from '../types';
 import type { Field } from './field';
 import type { Model, Query } from './types';
 export type OplogEntry = {
     ts: Timestamp;
     ns: string;
     op: 'i' | 'u' | 'd' | 'c' | 'n';
-    o: Record<string, unknown>;
+    o: Dict<unknown>;
     o2?: {
         _id: string;
     };

package/package.json

@@ -1,23 +1,42 @@
 {
-  "name": "@omegup/msync",
-  "version": "0.1.62",
-  "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/",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/Omegup/msync/issues"
-  },
-  "main": "index.js",
-  "module": "index.esm.js",
-  "typings": "index.d.ts",
-  "dependencies": {
-    "dayjs": "^1.11.9",
-    "dotenv": "^16.3.1",
-    "json-canonicalize": "^2.0.0",
-    "mongodb": "^6.8.0"
-  }
-}
+    "name": "@omegup/msync",
+    "version": "0.1.63",
+    "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/",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/Omegup/msync/issues"
+    },
+    "main": "index.js",
+    "module": "index.esm.js",
+    "typings": "index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts",
+            "import": "./index.esm.js",
+            "require": "./index.js"
+        },
+        "./adapters/mongodb": {
+            "types": "./adapters/mongodb.d.ts",
+            "import": "./adapters/mongodb.esm.js",
+            "require": "./adapters/mongodb.js"
+        }
+    },
+    "dependencies": {
+        "dayjs": "^1.11.9",
+        "dotenv": "^16.3.1",
+        "json-canonicalize": "^2.0.0"
+    },
+    "peerDependencies": {
+        "mongodb": "^6.8.0"
+    },
+    "peerDependenciesMeta": {
+        "mongodb": {
+            "optional": true
+        }
+    }
+}

package/types/global-aug.d.ts

@@ -4,7 +4,7 @@ import type { AsNum, GetDom } from './global';
 export {};
 declare global {
     type Entry<T, K extends keyof T = keyof T> = readonly [string, T[string & K]] & {
-        [k in K]: readonly [string & k, T[k]];
+        [k in K]?: readonly [string & k, T[k]];
     }[K];
     interface ObjectConstructor {
         entries<T, _ = 0>(object?: T): readonly Entry<T>[];

package/types/json.d.ts

@@ -1,5 +1,5 @@
-import type { Timestamp } from 'mongodb';
 import type { Type } from './class';
+import type { Timestamp } from './mongo';
 import type { Omit } from './global';
 export type { Type } from './class';
 export type U = undefined;
@@ -19,8 +19,8 @@ export interface JsonArr {
 export type A = {
     [Type]: typeof array;
 };
-export type Arr<T, N extends number = number> = A & {
-    readonly [_ in N]: T;
+export type Arr<T> = A & {
+    readonly [_: number]: T;
 };
 type Obj = {
     [Type]: typeof object;
@@ -32,6 +32,9 @@ export type RORec<K extends keyof never, T = unknown> = {
 export type PRRec<K extends keyof never, T = unknown> = {
     [P in K]?: T;
 };
+export type Dict<T> = {
+    [P: string]: T;
+};
 export type Par<K extends string, V extends Rec<K, jsonItem>> = {
     readonly [k in K]?: V[k] | N;
 };
@@ -49,7 +52,12 @@ export type raw = readonly rawItem[] | RawObj;
 export type StrKey<T> = string & keyof T;
 export type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
 export type ReplaceQ<R extends Q, VV, Q extends O> = Omit<R, StrKey<VV>> & Omit<VV, StrKey<Q>> & Q;
-export type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? {} extends {
+type AnyKeyed = {
+    [x: string]: never;
+    [x: number]: never;
+    [x: symbol]: never;
+};
+export type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? [Record<string, 1>] extends [never] ? [Record<T, 1>] extends [never] ? never : V : AnyKeyed extends {
     [K in T]: 1;
 } ? never : V : V;
 type NoUnion<T, V = T> = T extends T ? ([V] extends [T] ? T : never) : never;

package/types/mongo.d.ts

@@ -1,24 +1,84 @@
-import 'mongodb';
-import { BSON } from 'mongodb';
+import type { PRRec } from './json';
 export declare const RawStage: unique symbol;
-declare module 'mongodb' {
-    interface Collection<TSchema extends BSON.Document = BSON.Document> {
-        [RawStage]: {
-            (_: 2): TSchema;
-            (_: 1, x: TSchema): TSchema;
-        };
-        s: {
-            db: Db;
-        };
-    }
-    interface Db {
-        s: {
-            client?: MongoClient;
-        };
-        client: MongoClient;
-    }
-    interface Timestamp {
-        toExtendedJSON(): BSON.TimestampExtended;
-    }
-}
-export * from 'mongodb';
+export type Document = object;
+export type Filter<T> = PRRec<keyof T & string, unknown> & Document;
+export type UpdateFilter<T> = {
+    $set?: PRRec<keyof T & string, unknown>;
+} & Document;
+export interface Timestamp {
+    readonly _bsontype: 'Timestamp';
+    readonly high: number;
+    readonly low: number;
+    comp(other: unknown): number;
+}
+export interface UUID {
+    toString(encoding: 'base64'): string;
+}
+export interface Driver {
+    Timestamp: {
+        new (value: bigint): Timestamp;
+        new (value: {
+            t: number;
+            i: number;
+        }): Timestamp;
+    };
+    UUID: new () => UUID;
+}
+export interface Cursor<T> extends AsyncIterable<T> {
+    next(): Promise<T | null>;
+    toArray(): Promise<T[]>;
+    close(): Promise<void>;
+}
+export type IndexSpecification = Document;
+export type CreateIndexesOptions = Document & {
+    name?: string;
+    partialFilterExpression?: Document;
+};
+export type UpdateOptions = {
+    upsert?: boolean;
+};
+export interface Commander {
+    command<T extends object = PRRec<string, unknown>>(command: Document): Promise<T>;
+}
+export interface Client {
+    db(name: string): Db;
+}
+export interface Db extends Commander {
+    readonly s: {
+        readonly client?: Client;
+    };
+    readonly client: Client;
+    readonly namespace: string;
+    admin(): Commander;
+    collection<T = Document>(name: string): Collection<T>;
+    createCollection(name: string): Promise<unknown>;
+    listCollections(filter: Document, options: {
+        nameOnly: true;
+    }): Cursor<{
+        name: string;
+    }>;
+}
+export interface Collection<TSchema = Document> {
+    readonly s: {
+        readonly db: Db;
+    };
+    readonly collectionName: string;
+    readonly namespace: string;
+    readonly dbName: string;
+    [RawStage]: {
+        (_: 2): TSchema;
+        (_: 1, x: TSchema): TSchema;
+    };
+    createIndex(spec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
+    findOne(filter: Document): Promise<TSchema | null>;
+    find(filter: Document, options?: Document): Cursor<TSchema>;
+    updateOne(filter: Document, update: Document | readonly Document[], options?: UpdateOptions): Promise<unknown>;
+    updateMany(filter: Document, update: Document | readonly Document[]): Promise<unknown>;
+    deleteOne(filter: Document): Promise<unknown>;
+    deleteMany(filter: Document): Promise<unknown>;
+    drop(): Promise<unknown>;
+}
+export type WatchStream<T = {}> = {
+    close(): Promise<void>;
+    tryNext(): Promise<T | null>;
+};

package/types/view.d.ts

@@ -1,8 +1,7 @@
-import type { Collection, Db } from 'mongodb';
 import type { Del, Expr, Model, Query } from '../lib/types';
 import type { ExactKeys } from '../lib/utils/map-object';
 import type { O, StrKey } from './json';
-import type { RawStage } from './mongo';
+import type { Collection, Db, RawStage } from './mongo';
 interface CommonCollection {
     readonly s: {
         readonly db: Db;

package/test/mongodb.d.ts

@@ -1,9 +0,0 @@
-import { Collection, MongoClient } from 'mongodb';
-import type { AsynIter, Iterator } from '../lib/types';
-import type { ID, doc } from '../types';
-import type { Db, OptionalUnlessRequiredId } from 'mongodb';
-export declare const run: <T, Info>(cont: Iterator<T, Info>) => Promise<never>;
-export declare const iterate: <T>([, next]: AsynIter<T>) => PromiseLike<never>;
-export declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<import("mongodb").Document>;
-export declare const prepare: (testName?: string) => Promise<MongoClient>;
-export declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;

package/test/uri.d.ts

@@ -1 +0,0 @@
-export declare const uri: string;