@omegup/msync 0.0.43 → 0.0.44

package/lib/expression/val.d.ts

@@ -0,0 +1,25 @@
+import type { Timestamp } from 'mongodb';
+import type { Arr, N, O, RORec, StrKey, jsonItem, rawItem } from '../../types';
+import type { Expr } from '../types';
+import type { ExprsExact } from './concat';
+export declare const val: <T extends rawItem>(val: T) => Expr<T, unknown>;
+export declare const current: Expr<Timestamp, unknown>;
+export declare const $let: <T, D, C, V extends RORec<string, jsonItem>>(vars: ExprsExact<V, D, C>, inExpr: Expr<T, D, C & V>) => Expr<T, D, C>;
+export declare const nil: Expr<null, unknown>;
+export declare const $getField: {
+    <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T, D, C>, field: K): Expr<T[K], D, C>;
+    <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T | N, D, C>, field: K): Expr<T[K] | null, D, C>;
+};
+export type NoRaw<T> = T extends Arr<infer U> ? NoRaw<U>[] : T extends readonly unknown[] ? {
+    [K in keyof T]: NoRaw<T[K]>;
+} : T extends O ? {
+    [K in StrKey<T>]: NoRaw<T[K]>;
+} : T;
+export type RONoRaw<T> = T extends Arr<infer U> ? readonly RONoRaw<U>[] : T extends readonly unknown[] ? {
+    readonly [K in keyof T]: RONoRaw<T[K]>;
+} : T extends O ? {
+    readonly [K in StrKey<T>]: RONoRaw<T[K]>;
+} : T;
+export declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: NoRaw<A>) => RONoRaw<T>, ...args: { [X in keyof A]: Expr<A[X], D, C>; }) => Expr<T, D, C>;
+export declare const rand: () => string;
+export declare const $rand: Expr<string, unknown, unknown>;

package/lib/field/field.d.ts

@@ -0,0 +1,25 @@
+import type { Arr, AsLiteral, N, O, RORec, Undef } from '../../types';
+import type { Expr, Query } from '../types';
+import type { Predicate } from '../types/predicate';
+export declare class Field<in R, out V, in C = unknown> {
+    private field;
+    private raw;
+    private concat;
+    has<R extends O>(this: Field<R, V>, p: Predicate<V>): Query<R, C>;
+    has<R extends O, V>(this: Field<R, Arr<V>>, p: Predicate<V>): Query<R, C>;
+    private constructor();
+    static root: <T extends O>() => Field<T, T, unknown>;
+    static ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;
+    of<V, K extends keyof V, _ extends 0 = 0>(this: Field<R, Arr<V>, C>, k: AsLiteral<K>): Field<R, Arr<V[K]>, C>;
+    of<V, K extends keyof V, _ extends 1 = 1>(this: Field<R, O<V>, C>, k: K): Field<R, V[K], C>;
+    of<V, K extends keyof V, I extends N = never, _ extends 2 = 2>(this: Field<R, Arr<V> | Undef<I>, C>, k: K): Field<R, Arr<V[K]> | I, C>;
+    of<V, K extends keyof V, I extends N = never, _ extends 3 = 3>(this: Field<R, O<V> | Undef<I>, C>, k: K): Field<R, V[K] | I, C>;
+    with<V, W, C2 = unknown, _ extends 0 = 0>(this: Field<R, O<V>, C>, k: Field<O<V>, W, C2>): Field<R, W, C & C2>;
+    with<V, W, C2 = unknown, _ extends 1 = 1>(this: Field<R, Arr<V>, C>, k: Field<O<V>, Arr<W> | O<W>, C2>): Field<R, Arr<W>, C & C2>;
+    with<V, W, I extends N = never, C2 = unknown, _ extends 2 = 2>(this: Field<R, O<V> | Undef<I>, C>, k: Field<O<V>, W, C2>): Field<R, W | I, C & C2>;
+    with<V, W, I extends N = never, C2 = unknown, _ extends 3 = 3>(this: Field<R, Arr<V> | Undef<I>, C>, k: Field<O<V>, Arr<W> | O<W>, C2>): Field<R, Arr<W> | I, C & C2>;
+    str(this: Field<R, V>): string;
+    private exprRaw;
+    expr<R, V, C = unknown>(this: Field<R, V, C>): Expr<V, R, C>;
+}
+export declare const root: <T extends O>() => Field<T, T, unknown>, ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;

package/lib/field/index.d.ts

@@ -0,0 +1 @@
+export * from './field';

package/lib/machine.d.ts

@@ -0,0 +1,9 @@
+import type { Iterator, HasJob } from './types';
+export declare class Machine<Result = unknown> {
+    private sources;
+    constructor(root?: Iterator<Result, HasJob>);
+    add(x: Iterator<Result, HasJob>): void;
+    runner(): Iterator<Result, HasJob>;
+    start(cb?: (info: HasJob) => void | boolean): Promise<never>;
+}
+export declare const wrap: <Result>(root: Machine<Result>) => Machine<Result>;

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

@@ -0,0 +1,13 @@
+import { Timestamp } from 'mongodb';
+export declare const $eq: <T extends unknown>(operand: import("../../types").rawItem & T) => import("../types").Predicate<T>;
+export declare const $ne: <T extends unknown>(operand: import("../../types").rawItem & T) => import("../types").Predicate<T>;
+type Numeric = number | Timestamp | Date;
+export declare const comp: <D2 extends Numeric = number>(op: "$lte" | "$gte" | "$lt" | "$gt") => <T extends D2>(operand: import("../../types").rawItem & D2) => import("../types").Predicate<D2>;
+export declare const $gt: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export declare const $gtTs: <T extends Timestamp>(operand: import("../../types").rawItem & Timestamp) => import("../types").Predicate<Timestamp>;
+export declare const $gteTs: <T extends Timestamp>(operand: import("../../types").rawItem & Timestamp) => import("../types").Predicate<Timestamp>;
+export declare const $lt: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export declare const dateLt: <T extends Date>(operand: import("../../types").rawItem & Date) => import("../types").Predicate<Date>;
+export declare const $gte: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export declare const $lte: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export {};

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

@@ -0,0 +1,3 @@
+import type { O } from '../../types';
+import type { Expr, Query } from '../types';
+export declare const $expr: <D extends O, C>(expr: Expr<boolean, D, C>) => Query<D, C>;

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

@@ -0,0 +1,2 @@
+export declare const $in: <T extends unknown>(operand: import("../../types").rawItem & readonly T[]) => import("../types").Predicate<T>;
+export declare const $nin: <T extends unknown>(operand: import("../../types").rawItem & readonly T[]) => import("../types").Predicate<T>;

package/lib/predicate/index.d.ts

@@ -0,0 +1,3 @@
+export * from './$eq';
+export * from './$expr';
+export * from './$in';

package/lib/predicate/utils.d.ts

@@ -0,0 +1,5 @@
+import type { App, HKT, rawItem } from '../../types';
+import type { Predicate } from '../types';
+type Operators = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin';
+export declare const operator: <K extends Operators, F extends HKT<Dom, HKT<Dom, Dom>>, Dom extends unknown, Default extends Dom = Dom, G extends HKT<Dom, HKT<Dom, Dom>> = F>() => <D2 extends Dom = Default>(op: K) => <T extends D2>(operand: rawItem & App<App<F, D2>, T>) => Predicate<App<App<G, D2>, T>>;
+export {};

package/lib/query/index.d.ts

@@ -0,0 +1 @@
+export { $and, $nor, $or } from './logic';

package/lib/query/logic.d.ts

@@ -0,0 +1,11 @@
+import type { N, O } from '../../types';
+import type { Query } from '../types';
+type Many<T> = readonly (T | N)[];
+type Combiner = {
+    <T extends O, C = unknown>(first: Query<T, C>, ...args: Many<Query<T, C>>): Query<T, C>;
+    <T extends O, C = unknown>(...args: Many<Query<T, C>>): Query<T, C> | undefined;
+};
+export declare const $and: Combiner;
+export declare const $nor: Combiner;
+export declare const $or: Combiner;
+export {};

package/lib/stream/aggregate.d.ts

@@ -0,0 +1,7 @@
+import type { AggregateCommand } from '../types/aggregate';
+import type { ReadonlyCollection } from '../../types';
+import type { RawStages } from '../types';
+export declare const aggregate: <Result>(input: <E>(consume: <S, B>(value: {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, B, Result>;
+}) => E) => E, snapshot?: boolean, start?: number) => Promise<AggregateCommand<Result>>;

package/lib/types/accumulator.d.ts

@@ -0,0 +1,30 @@
+import type { Expr } from './expr';
+import type { HKT, I, N, O, 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;
+declare const Accumulator: unique symbol;
+export interface AccumulatorRaw<in Doc, out T, in C = unknown> extends RawObj {
+    [Type](_: typeof AccumulatorRaw, source: Doc, ctx: C): readonly [typeof AccumulatorRaw, T];
+}
+export interface AccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: Accumulator<T, I<unknown, this>, C>;
+}
+export type Accumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, AccumulatorHKT<T, C>>;
+export interface DeltaAccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: DeltaAccumulator<T, I<unknown, this>, C>;
+}
+export type DeltaAccumulators<T, V extends RORec<string, jsonItem>, 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 Accumulator<in Doc, out T, in Ctx = unknown> = {
+    [Type]?(_: typeof Accumulator): typeof Accumulator;
+    raw: {
+        <DeltaD extends O, I extends U>(f: Field<DeltaD, Doc | Undef<I>>): AccumulatorRaw<T | I, DeltaD, Ctx>;
+    };
+};
+export type Part<Doc> = Rec<'v', Doc> & RORec<'old', boolean>;
+export type DeltaAccumulator<in out Doc, in out T, in out Ctx = unknown> = {
+    group: Accumulator<Part<Doc>, T, Ctx>;
+    merge: <D, C = Ctx>(a: Expr<T | N, D, C>, b: Expr<T, D, C>) => Expr<T, D, C>;
+};
+export {};

package/lib/types/aggregate.d.ts

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

package/lib/types/expr.d.ts

@@ -0,0 +1,27 @@
+import type { O, Type, U, Undef, rawItem } from '../../types';
+import type { Field } from '../field';
+declare const Expr: unique symbol;
+declare const ExprRaw: unique symbol;
+export type ExprRaw<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof ExprRaw): void;
+    [ExprRaw]?(doc: Doc, ctx: Ctx): T;
+    get: () => rawItem;
+};
+export type Expr<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof Expr): void;
+    [Expr]?(doc: Doc, ctx: Ctx): T;
+    raw: {
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, Doc | Undef<I>, C>): ExprRaw<T | I, DeltaD, Ctx & C>;
+    };
+};
+export type BoolExpr<in D1, in D2, in Ctx = unknown> = {
+    [Type]?(x: typeof Expr): void;
+    [Expr](doc: D1, ctx: Ctx): true;
+    [Expr](doc: D2, ctx: Ctx): false;
+    raw: {
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D1 | D2 | Undef<I>, C>): ExprRaw<boolean, DeltaD, Ctx & C>;
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D1 | Undef<I>, C>): ExprRaw<true, DeltaD, Ctx & C>;
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D2 | Undef<I>, C>): ExprRaw<false, DeltaD, Ctx & C>;
+    };
+};
+export {};

package/lib/types/extern.d.ts

@@ -0,0 +1,3 @@
+export type { Accumulators, DeltaAccumulators, DeltaAccumulator } from './accumulator';
+export type { Expr } from './expr';
+export type { RawStages, SnapshotStreamExecutionResult, TS, Model, Delta } from './stream';

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './machine';
+export * from './query';
+export * from './stream';
+export * from './expr';
+export * from './predicate';
+export * from './accumulator';
+export * from './lookup';
+export * from './aggregate';

package/lib/types/lookup.d.ts

@@ -0,0 +1,19 @@
+import type { AsLiteral, O, ReadonlyCollection } from '../../types';
+import type { ExprsExact } from '../expression/concat';
+import type { Field } from '../field';
+import type { RawStages } from '../types';
+export type LookupArgs<T extends O, U extends O, R, K extends string, Ctx, C, s = string> = {
+    vars: ExprsExact<Ctx, T, C>;
+    k: AsLiteral<K>;
+} & ({
+    coll: ReadonlyCollection<R>;
+    pipeline: RawStages<unknown, R, U, Ctx & C>;
+    fields?: {
+        foreign: Field<R, s>;
+        local: Field<T, s>;
+    };
+} | {
+    coll?: never;
+    pipeline: RawStages<unknown, null, U, Ctx & C>;
+    fields?: never;
+});

package/lib/types/machine.d.ts

@@ -0,0 +1,17 @@
+export type HasJob = {
+    job: object | undefined;
+};
+export type Runner<T, Info extends HasJob> = Iterator<T, Info>;
+export type NextFrame<T, Info> = PromiseLike<Frame<T, Info>>;
+export type Frame<T, Info> = {
+    data: T;
+    info: Info;
+    cont: Iterator<T, Info>;
+};
+export type IteratorResult<out T, out Info> = {
+    next: NextFrame<T, Info>;
+    stop: Iterator<T, Info>;
+    clear: () => Promise<unknown>;
+};
+export type Iterator<out T, out Info> = () => IteratorResult<T, Info>;
+export type AsynIter<T> = readonly [T, () => PromiseLike<AsynIter<T>>];

package/lib/types/predicate.d.ts

@@ -0,0 +1,14 @@
+import type { Expr } from '../types';
+import type { Type, RawObj, O } from '../../types';
+import type { Field } from '../field';
+declare const Predicate: unique symbol;
+declare const PredicateRaw: unique symbol;
+export type PredicateRaw = RawObj & {
+    [Type]?(x: typeof PredicateRaw): void;
+};
+export interface Predicate<in V> {
+    [Type]?(x: typeof Predicate, _: V): void;
+    raw: PredicateRaw;
+    expr: <D extends O, C>(field: Field<D, V, C>) => Expr<boolean, D, C>;
+}
+export {};

package/lib/types/query.d.ts

@@ -0,0 +1,12 @@
+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>;
+};
+export {};

package/lib/types/stream.d.ts

@@ -0,0 +1,67 @@
+import type { BSON, Filter, Timestamp, UpdateFilter } from 'mongodb';
+import type { App, HKT, ID, O, RawObj, ReadonlyCollection, Rec, Type, WriteonlyCollection } from '../../types';
+import type { Field } from '../field';
+import type { HasJob, Runner } from './machine';
+declare const RawStage: unique symbol;
+type RawArr = readonly RawObj[];
+export interface RawStages<out Q, in S extends Q, out R extends Q, in C = unknown, out M = number> extends RawArr {
+    [Type]?(_: typeof RawStage, source: S, ctx: C, q: Q): readonly [typeof RawStage, R, M, Q];
+}
+export type FRawStages<out Q, in S extends Q & O, out R extends Q & O, in C = unknown, out M extends number = number> = <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, Q & O>, App<F, S>, App<F, R>, C, M>;
+export type DeltaStages<out Q, in S extends Q & O, out R extends Q & O, in C = unknown> = {
+    delta: RawStages<unknown, Delta<S>, Delta<R>, C>;
+    raw: FRawStages<Q, S, R, C>;
+};
+export type LinStages<out Q, in S extends Q, out R extends Q, in C = unknown> = {
+    lin: RawStages<Q, S, R, C, 1>;
+};
+export type TStages<in out S, out Q, in out B extends Q, out R extends Q, M extends number = number> = {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, S, B, unknown, M>;
+    exec: RawStages<Q, B, R, unknown, M>;
+};
+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[]];
+};
+export type TeardownRecord<W, M extends keyof Actions<W>> = {
+    collection: WriteonlyCollection<W>;
+    method: M;
+    params: Actions<W>[M];
+};
+export type StreamRunnerParam<in V, out Result> = {
+    raw: (first: boolean) => RawStages<unknown, V, Result>;
+    teardown: <R>(consume: <W, M extends keyof Actions<W>>(x: TeardownRecord<W, M>) => R) => R;
+};
+export type StreamRunner<out V> = <Result>(input: StreamRunnerParam<V, Result>) => Runner<readonly Result[], HasJob>;
+export type SimpleStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<V>;
+};
+export type SnapshotStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<Delta<V>>;
+    readonly stages: Stages<Before<Q>, Before<V>, UBefore<Q>>;
+};
+export type Stream<out Q extends O, in out T extends Q, in out F extends HKT<[O, O]>, in out G extends HKT<[O, O, O]>> = <Q2 extends O, Result extends Q2>(input: App<G, [Q2 | T, T, Result]>) => App<F, [Q | Q2, Result]>;
+export type TS = {
+    readonly touchedAt: Timestamp;
+};
+export type Del = O<{
+    readonly deletedAt: Timestamp;
+} & ID & TS>;
+export type D = O<{
+    readonly deletedAt?: Timestamp | null | undefined;
+} & ID>;
+export type Model = D & TS;
+export type OutInput<T, A = T | null> = ID & Rec<'after', A>;
+export type SimpleStream<in out Q extends O, out T extends Q> = <Q2 extends O, Result extends Q2>(input: LinStages<Q2 | T, T, Result>) => SimpleStreamExecutionResult<Q | Q2, Result>;
+export type BA = 'before' | 'after';
+export type PreDelta<T, K extends BA = BA, E = unknown> = Rec<K, T> & E;
+export type Delta<T, K extends BA = BA, E = ID> = PreDelta<T | null, K, E>;
+export type Before<T> = PreDelta<T, 'before'>;
+export type After<T> = Delta<T, 'after'>;
+export type UBefore<T> = O & Partial<Delta<T | null, 'before'>>;
+export type UDelta<T, E = {
+    readonly updated: boolean;
+}> = Delta<T, 'after', ID> & UBefore<T> & E;
+export type SnapshotStream<out Q extends O, in out T extends Q> = <Q2 extends O, Result extends Q2>(input: DeltaStages<Q2 | T, T, Result>) => SnapshotStreamExecutionResult<Q | Q2, Result>;
+export {};

package/lib/update/index.d.ts

@@ -0,0 +1 @@
+export { set, to } from './updater';

package/lib/update/updater.d.ts

@@ -0,0 +1,19 @@
+import type { Arr, HKT, I, N, O, StrKey, Type, notArr, rawItem } from '../../types';
+import { Field } from '../field';
+import type { Expr } from '../types';
+import { type MapO } from '../utils/map-object';
+declare const Updater: unique symbol;
+export type Updater<in R, in T, out V, in C = unknown> = {
+    [Type]?(x: typeof Updater, r: R, t: T, c: C): V;
+    readonly raw: <D extends O>(f: Field<D, R | N>) => readonly (readonly [string, rawItem])[];
+};
+export declare const subUpdater: <P extends O, D, T, V, Ctx>(a: Updater<D, T, V, Ctx>, f: Field<P, D>) => Updater<P, T, V, Ctx>;
+export interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends HKT<StrKey<V>> {
+    readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
+}
+export type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
+export declare const set: <V>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit<Old, StrKey<V>> & V>, C>;
+export declare const weaken: <R, T, V, C = unknown>(updater: Updater<R, T, V, C>) => Updater<R | null, T | N, V | null, C>;
+export declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
+export declare const items: <R, T, V, C = unknown>(x: Updater<R, T, V, C>) => Updater<R, Arr<T>, Arr<V>, C>;
+export {};

package/lib/utils/before.d.ts

@@ -0,0 +1,3 @@
+import type { O } from '../../types';
+import type { Before, FRawStages, RawStages } from '../types';
+export declare const asBefore: <Q extends O, S extends Q, R extends Q, C = unknown>(f: FRawStages<Q, S, R, C>) => RawStages<Before<Q>, Before<S>, Before<R>, C>;

package/lib/utils/coll.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyCollection, WriteonlyCollection } from '../../types';
+export declare const dbcoll: (x: ReadonlyCollection<unknown> | WriteonlyCollection<never>) => {
+    db: string;
+    coll: string;
+};

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

@@ -0,0 +1,4 @@
+import type { Collection, CreateIndexesOptions, IndexSpecification } from 'mongodb';
+export declare const createIndex: (collection: {
+    readonly createIndex: Collection["createIndex"];
+}, indexSpec: IndexSpecification, options?: CreateIndexesOptions) => Promise<void>;

package/lib/utils/guard.d.ts

@@ -0,0 +1,18 @@
+import type { App, HKT, jsonItem, Literal, Par, Rec, RORec } from '../../types';
+export type Equal<Dom, T extends Dom, V extends Dom> = {
+    forward: <F extends HKT<Dom>>(x: App<F, T>) => App<F, V>;
+    forward1: (x: T) => V;
+    backward: <F extends HKT<Dom>>(x: App<F, V>) => App<F, T>;
+    backward1: (x: V) => T;
+};
+export declare const sym: <Dom, T extends Dom, V extends Dom>(eq: Equal<Dom, T, V>) => Equal<Dom, V, T>;
+export declare const omitRORec: <K extends string, E extends string, R extends string, T extends unknown>() => Equal<unknown, RORec<Exclude<K, E | R>, T>, Omit<RORec<Exclude<K, E | R>, T>, R>>;
+type s = keyof any;
+export declare const omitPick: <K extends s, E extends s, R extends s, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Pick<T, Exclude<K, E | R>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
+export declare const omitExclude: <K extends s, E extends s, R extends s, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Omit<T, E & Exclude<K, keyof T>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
+export declare const renamedFields: <K extends s, F extends HKT<K, s>, G extends HKT<App<F, K>>>() => Equal<string | number | symbol, keyof { [P in K as App<F, P>]: App<G, P>; }, App<F, K>>;
+export declare const doubleExclude: <K extends string, E extends s, R extends s>() => Equal<K, K, Exclude<K, E & Exclude<Literal<R>, K>>>;
+export declare const excludeIdem: <K extends s, E extends s, S extends E = E>() => Equal<Exclude<K, E>, Exclude<K, E>, Exclude<Exclude<K, E>, S>>;
+export declare const eqPar: <K extends string, T extends Rec<K, jsonItem>, K2 extends K>() => Equal<unknown, Par<K2, T>, Par<K, T>>;
+export declare const notExtendExcluded: <Key extends keyof any, Others extends keyof any, Source extends keyof any, Denied extends keyof any, F extends HKT<Others | Exclude<Source, Denied | Key>, Dom>, Else extends Dom, Dom = unknown>() => Equal<Dom, Key extends Others | Exclude<Source, Key | Denied> ? App<F, Key> : Else, Key extends Others ? App<F, Key> : Else>;
+export {};

package/lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { log } from './log';
+export { createIndex } from './db-indexes';
+export { map1, noop } from './json';

package/lib/utils/json.d.ts

@@ -0,0 +1,9 @@
+import type { AsLiteral, Rec } from '../../types';
+export declare const id: <T>(x: T) => T;
+export declare const defined: <T>(x: T | undefined | null) => x is T;
+export declare const noop: () => void;
+export declare const anoop: () => Promise<void>;
+export declare const asRec: <K extends string, T>(x: Record<K, T>) => Rec<K, T>;
+export declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
+    readonly [_: string]: [K, Im];
+};

package/lib/utils/log.d.ts

@@ -0,0 +1 @@
+export declare const log: (...args: unknown[]) => void;

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

@@ -0,0 +1,41 @@
+import type { App, HKT, I, IdHKT, 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<StrKey<T>>> = MapOPart<T, F> & {
+    readonly [P: string]: readonly [StrKey<T>, unknown];
+};
+export type MapK<K extends s, F extends HKT<K>> = MapO<RORec<K>, F>;
+export type MapOPart<T, F extends HKT<StrKey<T>>, K extends keyof T = StrKey<T>> = {
+    readonly [P in K]: readonly [P, App<F, P & string>];
+};
+export type MapKPart1<T, F extends HKT<StrKey<T>>> = {
+    readonly [P in StrKey<T>]: App<F, P>;
+};
+export type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
+export interface MappedHKT<T, F extends HKT<T[StrKey<T>]>> extends HKT<StrKey<T>> {
+    readonly out: App<F, T[I<StrKey<T>, this>]>;
+}
+export declare const mapExactToObject0: <T, F extends HKT<StrKey<T>>, G extends HKT<StrKey<T>>>(x: MapO<T, F>, f: <P extends StrKey<T>>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<T, G>;
+export declare const mapExactToObject1: <K extends string, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<RORec<K>, G>;
+export interface WithKey1<K extends string, G extends HKT<K>> extends HKT<K> {
+    readonly out: readonly [I<K, this>, App<G, I<K, this>>];
+}
+export declare const mapExact0: <T, F extends HKT<StrKey<T>>, G extends HKT<StrKey<T>>>(x: MapO<T, F>, f: <P extends StrKey<T>>(v: App<F, P>, k: P) => App<G, P>) => MapO<T, G>;
+export declare const mapExact1: <K extends s, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapK<K, G>;
+export declare const mapExactToObject: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<StrKey<T>>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, P>) => ExactPart1<T, G>;
+export declare const mapExact: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<T[StrKey<T>]>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, T[P]>) => Exact<T, G>;
+type Dom<T, V> = HKT<T[StrKey<T>] | V[StrKey<V>]>;
+export declare const spread: <T, V, F extends Dom<T, V>, E = unknown, No extends keyof V = never>(a: Exact<Omit<T, No>, F>, b: Exact<V, F>) => Exact<V & Omit<T, keyof V> & Pick<E, symbol & keyof E>, F>;
+export interface MergeHKT<T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, No extends keyof V = never> extends HKT<StrKey<V & Omit<T, No>>> {
+    readonly out: I<StrKey<V & Omit<T, No>>, this> extends StrKey<V> ? App<F2, I<StrKey<V>, this>> : App<F1, I<StrKey<Omit<T, No>>, this>>;
+}
+export declare const spread0: <T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, E = unknown, No extends keyof V = never>(a: MapO<Omit<T, No>, F1>, b: MapO<V, F2>) => MapO<V & Omit<T, No> & Pick<E, symbol & keyof E>, MergeHKT<T, V, F1, F2, No>>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { Iterator, HasJob } from '../../types';
+export { mergeIterators } from './merge';
+export declare const firstWorksMerge: <Result, Info extends HasJob>(iters: Iterator<Result, Info>[]) => Iterator<Result, {
+    readonly key: string;
+    readonly value: Info;
+} & HasJob>;

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

@@ -0,0 +1,2 @@
+export { firstWorksMerge, mergeIterators } from './combiners';
+export { Machine, wrap } from '../../machine';

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

@@ -0,0 +1,7 @@
+import type { 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: {
+    sources: SourceIteratorResults<K, Result, Info>;
+    interrupt?: (key: KEYS) => boolean;
+    select?: Race<K, Result, Info>;
+}) => IteratorResult<Result, SourceResults<K, Info>>;

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

@@ -0,0 +1,3 @@
+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>>;

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

@@ -0,0 +1,19 @@
+import type { Frame, IteratorResult, HasJob } from '../../types';
+export type KEYS = string;
+export type SourceIteratorResults<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+    readonly [P in K]: IteratorResult<Result, Info[P]>;
+};
+export type SourceResults<K extends KEYS, Info extends Record<K, HasJob>> = {
+    readonly [P in K]: {
+        readonly key: P;
+        readonly value: Info[P];
+        readonly job: Info[P]['job'];
+    };
+}[K];
+export type RaceWinner<K extends KEYS, Result, Info extends Record<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>>;

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

@@ -0,0 +1,4 @@
+import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
+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>>;

package/lib/utils/tear-down.d.ts

@@ -0,0 +1,2 @@
+import type { Iterator } from '../types';
+export declare const addTeardown: <T, Info>(it: Iterator<T, Info>, tr?: () => Promise<void>) => Iterator<T, Info>;

package/lib/watch.d.ts

@@ -0,0 +1,15 @@
+import type { BSON, Db, Timestamp } from 'mongodb';
+import type { O, StrKey, View } from '../types';
+import { type Field } from './field';
+import type { Model, Query } from './types';
+export declare const changeKeys: readonly ["fullDocument", "fullDocumentBeforeChange"];
+export type ChangeKey = (typeof changeKeys)[number];
+export type Change<T extends Model> = O<{
+    readonly fullDocument: T;
+    readonly fullDocumentBeforeChange: T;
+}>;
+export declare const subQ: <D extends O, C, DeltaD extends O>(a: Query<D, C>, f: Field<DeltaD, D>) => Query<DeltaD, C>;
+export declare const makeWatchStream: <V extends Model, K extends StrKey<V>>(db: Db, { collection, projection: p, hardMatch: m }: View<V, K>, startAt: Timestamp, streamName: string) => {
+    tryNext: () => Promise<import("mongodb").ChangeStreamDocument<BSON.Document> | null>;
+    close: () => Promise<void>;
+};

package/package.json

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

package/test/mongodb.d.ts

@@ -0,0 +1,9 @@
+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

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

package/types/class.d.ts

@@ -0,0 +1 @@
+export declare const Type: unique symbol;

package/types/extern.d.ts

@@ -0,0 +1,3 @@
+export type { Type } from './class';
+export type { Arr, ID, N, O, Rec, StrKey, doc, OPick, OPickD, RORec, Replace } from './index';
+export type { AsLiteral, notArr, WriteonlyCollection, Collection, Timestamp } from './index';