mam 1.11.921 → 1.11.923

package/node.d.ts

@@ -16,11 +16,17 @@ declare namespace $ {
 
 declare namespace $ {
     const $mol_ambient_ref: unique symbol;
+    /** @deprecated use $ instead */
     type $mol_ambient_context = $;
     function $mol_ambient(this: $ | void, overrides: Partial<$>): $;
 }
 
 declare namespace $ {
+    /**
+     * Proxy that delegates all to lazy returned target.
+     *
+     * 	$mol_delegate( Array.prototype , ()=> fetch_array() )
+     */
     function $mol_delegate<Value extends object>(proto: Value, target: () => Value): Value;
 }
 
@@ -90,57 +96,130 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Generates unique identifier. */
     function $mol_guid(length?: number, exists?: (id: string) => boolean): string;
 }
 
 declare namespace $ {
+    /** Special status statuses. */
     enum $mol_wire_cursor {
+        /** Update required. */
         stale = -1,
+        /** Some of (transitive) pub update required. */
         doubt = -2,
+        /** Actual state but may be dropped. */
         fresh = -3,
+        /** State will never be changed. */
         final = -4
     }
 }
 
 declare namespace $ {
+    /**
+     * Collects subscribers in compact array. 28B
+     */
     class $mol_wire_pub extends Object {
         constructor(id?: string);
         [Symbol.toStringTag]: string;
         data: unknown[];
         static get [Symbol.species](): ArrayConstructor;
+        /**
+         * Index of first subscriber.
+         */
         protected sub_from: number;
+        /**
+         * All current subscribers.
+         */
         get sub_list(): readonly $mol_wire_sub[];
+        /**
+         * Has any subscribers or not.
+         */
         get sub_empty(): boolean;
+        /**
+         * Subscribe subscriber to this publisher events and return position of subscriber that required to unsubscribe.
+         */
         sub_on(sub: $mol_wire_pub, pub_pos: number): number;
+        /**
+         * Unsubscribe subscriber from this publisher events by subscriber position provided by `on(pub)`.
+         */
         sub_off(sub_pos: number): void;
+        /**
+         * Called when last sub was unsubscribed.
+         **/
         reap(): void;
+        /**
+         * Autowire this publisher with current subscriber.
+         **/
         promote(): void;
+        /**
+         * Enforce actualization. Should not throw errors.
+         */
         fresh(): void;
+        /**
+         * Allow to put data to caches in the subtree.
+         */
         complete(): void;
         get incompleted(): boolean;
+        /**
+         * Notify subscribers about self changes.
+         */
         emit(quant?: $mol_wire_cursor): void;
+        /**
+         * Moves peer from one position to another. Doesn't clear data at old position!
+         */
         peer_move(from_pos: number, to_pos: number): void;
+        /**
+         * Updates self position in the peer.
+         */
         peer_repos(peer_pos: number, self_pos: number): void;
     }
 }
 
 declare namespace $ {
+    /** Generic subscriber interface */
     interface $mol_wire_sub extends $mol_wire_pub {
         temp: boolean;
         pub_list: $mol_wire_pub[];
+        /**
+         * Begin auto wire to publishers.
+         * Returns previous auto subscriber that must me transfer to the `end`.
+         */
         track_on(): $mol_wire_sub | null;
+        /**
+         * Returns next auto wired publisher. It can be easely repormoted.
+         * Or promotes next publisher to auto wire its togeter.
+         * Must be used only between `track_on` and `track_off`.
+         */
         track_next(pub?: $mol_wire_pub): $mol_wire_pub | null;
         pub_off(pub_pos: number): void;
+        /**
+         * Unsubscribes from unpromoted publishers.
+         */
         track_cut(sub: $mol_wire_pub | null): void;
+        /**
+         * Ends auto wire to publishers.
+         */
         track_off(sub: $mol_wire_pub | null): void;
+        /**
+         * Receive notification about publisher changes.
+         */
         absorb(quant: $mol_wire_cursor, pos: number): void;
+        /**
+         * Unsubscribes from all publishers.
+         */
         destructor(): void;
     }
 }
 
 declare namespace $ {
     let $mol_wire_auto_sub: $mol_wire_sub | null;
+    /**
+     * When fulfilled, all publishers are promoted to this subscriber on access to its.
+     */
     function $mol_wire_auto(next?: $mol_wire_sub | null): $mol_wire_sub | null;
+    /**
+     * Affection queue. Used to prevent accidental stack overflow on emit.
+     */
     const $mol_wire_affected: ($mol_wire_sub | number)[];
 }
 
@@ -173,6 +252,13 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Publisher that can auto collect other publishers. 32B
+     *
+     * 	P1 P2 P3 P4 S1 S2 S3
+     * 	^           ^
+     * 	pubs_from   subs_from
+     */
     class $mol_wire_pub_sub extends $mol_wire_pub implements $mol_wire_sub {
         protected pub_from: number;
         protected cursor: $mol_wire_cursor;
@@ -189,6 +275,9 @@ declare namespace $ {
         complete_pubs(): void;
         absorb(quant?: $mol_wire_cursor, pos?: number): void;
         [$mol_dev_format_head](): any[];
+        /**
+         * Is subscribed to any publisher or not.
+         */
         get pub_empty(): boolean;
     }
 }
@@ -208,6 +297,13 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Suspendable task with support both sync/async api.
+     *
+     * 	A1 A2 A3 A4 P1 P2 P3 P4 S1 S2 S3
+     * 	^           ^           ^
+     * 	args_from   pubs_from   subs_from
+     **/
     abstract class $mol_wire_fiber<Host, Args extends readonly unknown[], Result> extends $mol_wire_pub_sub {
         readonly task: (this: Host, ...args: Args) => Result;
         readonly host?: Host | undefined;
@@ -234,7 +330,15 @@ declare namespace $ {
         fresh(): this | undefined;
         refresh(): void;
         abstract put(next: Result | Error | Promise<Result | Error>): Result | Error | Promise<Result | Error>;
+        /**
+         * Synchronous execution. Throws Promise when waits async task (SuspenseAPI provider).
+         * Should be called inside SuspenseAPI consumer (ie fiber).
+         */
         sync(): Awaited<Result>;
+        /**
+         * Asynchronous execution.
+         * It's SuspenseAPI consumer. So SuspenseAPI providers can be called inside.
+         */
         async_raw(): Promise<Result>;
         async(): Promise<Result> & {
             destructor(): void;
@@ -246,31 +350,48 @@ declare namespace $ {
 
 declare namespace $ {
     let $mol_compare_deep_cache: WeakMap<any, WeakMap<any, boolean>>;
+    /**
+     * Deeply compares two values. Returns true if equal.
+     * Define `Symbol.toPrimitive` to customize.
+     */
     function $mol_compare_deep<Value>(left: Value, right: Value): boolean;
 }
 
 declare namespace $ {
+    /** Logger event data */
     type $mol_log3_event<Fields> = {
         [key in string]: unknown;
     } & {
+        /** Time of event creation */
         time?: string;
+        /** Place of event creation */
         place: unknown;
+        /** Short description of event */
         message: string;
     } & Fields;
+    /** Logger function */
     type $mol_log3_logger<Fields, Res = void> = (this: $, event: $mol_log3_event<Fields>) => Res;
+    /** Log begin of some task */
     let $mol_log3_come: $mol_log3_logger<{}>;
+    /** Log end of some task */
     let $mol_log3_done: $mol_log3_logger<{}>;
+    /** Log error */
     let $mol_log3_fail: $mol_log3_logger<{}>;
+    /** Log warning message */
     let $mol_log3_warn: $mol_log3_logger<{
         hint: string;
     }>;
+    /** Log some generic event */
     let $mol_log3_rise: $mol_log3_logger<{}>;
+    /** Log begin of log group, returns func to close group */
     let $mol_log3_area: $mol_log3_logger<{}, () => void>;
+    /** Log begin of collapsed group only when some logged inside, returns func to close group */
     function $mol_log3_area_lazy(this: $, event: $mol_log3_event<{}>): () => void;
     let $mol_log3_stack: (() => void)[];
 }
 
 declare namespace $ {
+    /** Position in any resource. */
     class $mol_span extends $mol_object2 {
         readonly uri: string;
         readonly source: string;
@@ -278,9 +399,13 @@ declare namespace $ {
         readonly col: number;
         readonly length: number;
         constructor(uri: string, source: string, row: number, col: number, length: number);
+        /** Span for begin of unknown resource */
         static unknown: $mol_span;
+        /** Makes new span for begin of resource. */
         static begin(uri: string, source?: string): $mol_span;
+        /** Makes new span for end of resource. */
         static end(uri: string, source: string): $mol_span;
+        /** Makes new span for entire resource. */
         static entire(uri: string, source: string): $mol_span;
         toString(): string;
         toJSON(): {
@@ -289,14 +414,19 @@ declare namespace $ {
             col: number;
             length: number;
         };
+        /** Makes new error for this span. */
         error(message: string, Class?: ErrorConstructor): Error;
+        /** Makes new span for same uri. */
         span(row: number, col: number, length: number): $mol_span;
+        /** Makes new span after end of this. */
         after(length?: number): $mol_span;
+        /** Makes new span between begin and end. */
         slice(begin: number, end?: number): $mol_span;
     }
 }
 
 declare namespace $ {
+    /** Serializes tree to string in tree format. */
     function $mol_tree2_to_string(this: $, tree: $mol_tree2): string;
 }
 
@@ -305,37 +435,74 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Path by types in tree. */
     type $mol_tree2_path = Array<string | number | null>;
+    /** Hask tool for processing node. */
     type $mol_tree2_hack<Context> = (input: $mol_tree2, belt: $mol_tree2_belt<Context>, context: Context) => readonly $mol_tree2[];
+    /** Collection of hask tools for processing tree. */
     type $mol_tree2_belt<Context> = Record<string, $mol_tree2_hack<Context>>;
+    /**
+     * Abstract Syntax Tree with human readable serialization.
+     * Avoid direct instantiation. Use static factories instead.
+     * @see https://github.com/nin-jin/tree.d
+     */
     class $mol_tree2 extends Object {
+        /** Type of structural node, `value` should be empty */
         readonly type: string;
+        /** Content of data node, `type` should be empty */
         readonly value: string;
+        /** Child nodes */
         readonly kids: readonly $mol_tree2[];
+        /** Position in most far source resource */
         readonly span: $mol_span;
-        constructor(type: string, value: string, kids: readonly $mol_tree2[], span: $mol_span);
+        constructor(
+        /** Type of structural node, `value` should be empty */
+        type: string, 
+        /** Content of data node, `type` should be empty */
+        value: string, 
+        /** Child nodes */
+        kids: readonly $mol_tree2[], 
+        /** Position in most far source resource */
+        span: $mol_span);
+        /** Makes collection node. */
         static list(kids: readonly $mol_tree2[], span?: $mol_span): $mol_tree2;
+        /** Makes new derived collection node. */
         list(kids: readonly $mol_tree2[]): $mol_tree2;
+        /** Makes data node for any string. */
         static data(value: string, kids?: readonly $mol_tree2[], span?: $mol_span): $mol_tree2;
+        /** Makes new derived data node. */
         data(value: string, kids?: readonly $mol_tree2[]): $mol_tree2;
+        /** Makes struct node. */
         static struct(type: string, kids?: readonly $mol_tree2[], span?: $mol_span): $mol_tree2;
+        /** Makes new derived structural node. */
         struct(type: string, kids?: readonly $mol_tree2[]): $mol_tree2;
+        /** Makes new derived node with different kids id defined. */
         clone(kids: readonly $mol_tree2[], span?: $mol_span): $mol_tree2;
+        /** Returns multiline text content. */
         text(): string;
+        /** Parses tree format. */
+        /** @deprecated Use $mol_tree2_from_string */
         static fromString(str: string, uri?: string): $mol_tree2;
+        /** Serializes to tree format. */
         toString(): string;
+        /** Makes new tree with node overrided by path. */
         insert(value: $mol_tree2 | null, ...path: $mol_tree2_path): $mol_tree2;
+        /** Makes new tree with node overrided by path. */
         update(value: readonly $mol_tree2[], ...path: $mol_tree2_path): readonly $mol_tree2[];
+        /** Query nodes by path. */
         select(...path: $mol_tree2_path): $mol_tree2;
+        /** Filter kids by path or value. */
         filter(path: string[], value?: string): $mol_tree2;
         hack_self<Context extends {
             span?: $mol_span;
             [key: string]: unknown;
         } = {}>(belt: $mol_tree2_belt<Context>, context?: Context): readonly $mol_tree2[];
+        /** Transform tree through context with transformers */
         hack<Context extends {
             span?: $mol_span;
             [key: string]: unknown;
         } = {}>(belt: $mol_tree2_belt<Context>, context?: Context): $mol_tree2[];
+        /** Makes Error with node coordinates. */
         error(message: string, Class?: ErrorConstructor): Error;
     }
     class $mol_tree2_empty extends $mol_tree2 {
@@ -344,6 +511,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Syntax error with cordinates and source line snippet. */
     class $mol_error_syntax extends SyntaxError {
         reason: string;
         line: string;
@@ -353,6 +521,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Parses tree format from string. */
     function $mol_tree2_from_string(this: $, str: string, uri?: string): $mol_tree2;
 }
 
@@ -365,6 +534,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Module for working with terminal. Text coloring when output in terminal */
     class $mol_term_color {
         static reset: (str: string) => string;
         static bold: (str: string) => string;
@@ -396,6 +566,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** One-shot fiber */
     class $mol_wire_task<Host, Args extends readonly unknown[], Result> extends $mol_wire_fiber<Host, Args, Result> {
         static getter<Host, Args extends readonly unknown[], Result>(task: (this: Host, ...args: Args) => Result): (host: Host, args: Args) => $mol_wire_task<Host, Args, Result>;
         get temp(): boolean;
@@ -406,6 +577,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Convert a pseudo-synchronous (Suspense API) API to an explicit asynchronous one (for integrating with external systems). */
     export function $mol_wire_async<Host extends object>(obj: Host): ObjectOrFunctionResultPromisify<Host>;
     type FunctionResultPromisify<Some> = Some extends (...args: infer Args) => infer Res ? Res extends PromiseLike<unknown> ? Some : (...args: Args) => Promise<Res> : Some;
     type MethodsResultPromisify<Host extends Object> = {
@@ -428,6 +600,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Returns string key for any value. */
     function $mol_key<Value>(value: Value): string;
 }
 
@@ -449,6 +622,9 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Decorates method to fiber to ensure it is executed only once inside other fiber.
+     */
     function $mol_wire_method<Host extends object, Args extends readonly any[]>(host: Host, field: PropertyKey, descr?: TypedPropertyDescriptor<(...args: Args) => any>): {
         value: (this: Host, ...args: Args) => any;
         enumerable?: boolean;
@@ -460,14 +636,25 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Returns `Tuple` without first element.
+     *
+     * 	$mol_type_tail<[ 1 , 2 , 3 ]> // [ 2, 3 ]
+     */
     type $mol_type_tail<Tuple extends readonly any[]> = ((...tail: Tuple) => any) extends ((head: any, ...tail: infer Tail) => any) ? Tail : never;
 }
 
 declare namespace $ {
+    /**
+     * Returns last element of `Tuple`.
+     *
+     * 	$mol_type_tail<[ 1 , 2 , 3 ]> // 3
+     */
     type $mol_type_foot<Tuple extends readonly any[]> = Tuple['length'] extends 0 ? never : Tuple[$mol_type_tail<Tuple>['length']];
 }
 
 declare namespace $ {
+    /** Long-living fiber. */
     class $mol_wire_atom<Host, Args extends readonly unknown[], Result> extends $mol_wire_fiber<Host, Args, Result> {
         static solo<Host, Args extends readonly unknown[], Result>(host: Host, task: (this: Host, ...args: Args) => Result): $mol_wire_atom<Host, Args, Result>;
         static plex<Host, Args extends readonly unknown[], Result>(host: Host, task: (this: Host, ...args: Args) => Result, key: Args[0]): $mol_wire_atom<Host, Args, Result>;
@@ -475,6 +662,9 @@ declare namespace $ {
         static watcher: $mol_after_frame | null;
         static watch(): void;
         watch(): void;
+        /**
+         * Update atom value through another temp fiber.
+         */
         resync(args: Args): Error | Result | Promise<Error | Result>;
         once(): Awaited<Result>;
         channel(): ((next?: $mol_type_foot<Args>) => Awaited<Result>) & {
@@ -486,12 +676,14 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Decorates solo object channel to [mol_wire_atom](../atom/atom.ts). */
     export function $mol_wire_solo<Args extends any[]>(host: object, field: string, descr?: TypedPropertyDescriptor<(...args: Args) => any>): TypedPropertyDescriptor<(...args: First_optional<Args>) => any>;
     type First_optional<Args extends any[]> = Args extends [] ? [] : [Args[0] | undefined, ...$mol_type_tail<Args>];
     export {};
 }
 
 declare namespace $ {
+    /** Reactive memoizing multiplexed property decorator. */
     function $mol_wire_plex<Args extends [any, ...any[]]>(host: object, field: string, descr?: TypedPropertyDescriptor<(...args: Args) => any>): {
         value: (this: typeof host, ...args: Args) => any;
         enumerable?: boolean;
@@ -503,11 +695,33 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Reactive memoizing solo property decorator from [mol_wire](../wire/README.md)
+     * @example
+     * '@' $mol_mem
+     * name(next?: string) {
+     * 	return next ?? 'default'
+     * }
+     * @see https://mol.hyoo.ru/#!section=docs/=qxmh6t_sinbmb
+     */
     let $mol_mem: typeof $mol_wire_solo;
+    /**
+     * Reactive memoizing multiplexed property decorator [mol_wire](../wire/README.md)
+     * @example
+     * '@' $mol_mem_key
+     * name(id: number, next?: string) {
+     *  return next ?? 'default'
+     * }
+     * @see https://mol.hyoo.ru/#!section=docs/=qxmh6t_sinbmb
+     */
     let $mol_mem_key: typeof $mol_wire_plex;
 }
 
 declare namespace $ {
+    /**
+     * Convert asynchronous (promise-based) API to synchronous by wrapping function and method calls in a fiber.
+     * @see https://mol.hyoo.ru/#!section=docs/=1fcpsq_1wh0h2
+     */
     export function $mol_wire_sync<Host extends object>(obj: Host): ObjectOrFunctionResultAwaited<Host>;
     type FunctionResultAwaited<Some> = Some extends (...args: infer Args) => infer Res ? (...args: Args) => Awaited<Res> : Some;
     type ConstructorResultAwaited<Some> = Some extends new (...args: infer Args) => infer Res ? new (...args: Args) => Res : {};
@@ -553,6 +767,7 @@ interface $node {
 declare var $node: $node;
 
 declare namespace $ {
+    /** Run code without state changes */
     function $mol_wire_probe<Value>(task: () => Value, def?: Value): Value | undefined;
 }
 
@@ -631,6 +846,10 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Decorates method to fiber to ensure it is executed only once inside other fiber from [mol_wire](../wire/README.md)
+     * @see https://mol.hyoo.ru/#!section=docs/=1fcpsq_1wh0h2
+     */
     let $mol_action: typeof $mol_wire_method;
 }
 
@@ -700,6 +919,11 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Returns closure that returns constant value.
+     * @example
+     * const rnd = $mol_const( Math.random() )
+     */
     function $mol_const<Value>(value: Value): {
         (): Value;
         '()': Value;
@@ -731,6 +955,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Temporary buffer. Recursive usage isn't supported. */
     function $mol_charset_buffer(size: number): Uint8Array<ArrayBuffer>;
 }
 
@@ -761,6 +986,9 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Disable reaping of current subscriber
+     */
     function $mol_wire_solid(): void;
 }
 
@@ -793,6 +1021,10 @@ declare namespace $ {
         protected static changed: Set<$mol_file_base>;
         protected static frame: null | $mol_after_timeout;
         protected static changed_add(type: 'change' | 'rename', path: string): void;
+        /**
+         * Должно быть больше, чем время между событиями от вотчера при записи внешним процессом.
+         * Иначе запуск ресетов паралельно с изменением может привести к неконсистентности.
+         */
         static watch_debounce(): number;
         static flush(): void;
         protected static watching: boolean;
@@ -922,25 +1154,49 @@ declare namespace $ {
 }
 
 declare namespace $ {
-    type $mol_type_equals<A, B> = (<X>() => X extends A ? 1 : 2) extends (<X>() => X extends B ? 1 : 2) ? unknown : never;
+    /**
+     * Return `unknown` when `A` and `B` are the same type. `never` otherwise.
+     *
+     * 	$mol_type_equals< unknown , any > & number // true
+     * 	$mol_type_equals< never , never > & number // false
+     */
+    type $mol_type_equals<A, B> = (<X>() => X extends A ? 1 : 2) extends (<X>() => X extends B ? 1 : 2) ? true : false;
 }
 
 declare namespace $ {
-    type $mol_type_merge<Intersection> = Intersection extends (...a: any[]) => any ? Intersection : Intersection extends new (...a: any[]) => any ? Intersection : Intersection extends object ? $mol_type_merge_object<Intersection> extends Intersection ? unknown extends $mol_type_equals<{
+    /**
+     * Reqursive converts intersection of records to record of intersections
+     *
+     * 	// { a : { x : 1 , y : 2 } }
+     * 	$mol_type_merge< { a : { x : 1 } }&{ a : { y : 2 } } >
+     */
+    type $mol_type_merge<Intersection> = Intersection extends (...a: any[]) => any ? Intersection : Intersection extends new (...a: any[]) => any ? Intersection : Intersection extends object ? $mol_type_merge_object<Intersection> extends Intersection ? true extends $mol_type_equals<{
         [Key in keyof Intersection]: Intersection[Key];
     }, Intersection> ? Intersection : {
         [Key in keyof Intersection]: $mol_type_merge<Intersection[Key]>;
     } : Intersection : Intersection;
+    /**
+     * Flat converts intersection of records to record of intersections
+     *
+     * 	// { a: 1, b: 2 }
+     * 	$mol_type_merge< { a: 1 } & { b: 2 } >
+     */
     type $mol_type_merge_object<Intersection> = {
         [Key in keyof Intersection]: Intersection[Key];
     };
 }
 
 declare namespace $ {
+    /**
+     * Converts union of types to intersection of same types
+     *
+     * 	$mol_type_intersect< number | string > // number & string
+     */
     type $mol_type_intersect<Union> = (Union extends any ? (_: Union) => void : never) extends ((_: infer Intersection) => void) ? Intersection : never;
 }
 
 declare namespace $ {
+    /** Replaces properties of `Base` record by properties from `Over`. */
     type $mol_type_override<Base, Over> = Omit<Base, keyof Over> & Over;
 }
 
@@ -973,15 +1229,19 @@ declare namespace $ {
             readonly [k in key]: Source[key] extends string ? Source[key] : string;
         }> & $mol_regexp_groups<Source[key]>>;
     }[keyof Source]>> : never;
+    /** Type safe reguar expression builder */
     export class $mol_regexp<Groups extends Record<string, string>> extends RegExp {
         readonly groups: (Extract<keyof Groups, string>)[];
+        /** Prefer to use $mol_regexp.from */
         constructor(source: string, flags?: string, groups?: (Extract<keyof Groups, string>)[]);
         [Symbol.matchAll](str: string): RegExpStringIterator<RegExpExecArray & $mol_type_override<RegExpExecArray, {
             groups?: {
                 [key in keyof Groups]: string;
             };
         }>>;
+        /** Parses input and returns found capture groups or null */
         [Symbol.match](str: string): null | RegExpMatchArray;
+        /** Splits string by regexp edges */
         [Symbol.split](str: string): string[];
         test(str: string): boolean;
         exec(str: string): RegExpExecArray & $mol_type_override<RegExpExecArray, {
@@ -991,6 +1251,7 @@ declare namespace $ {
         }> | null;
         generate(params: Groups_to_params<Groups>): string | null;
         get native(): RegExp;
+        /** Makes regexp that greedy repeats this pattern with delimiter */
         static separated<Chunk extends $mol_regexp_source, Sep extends $mol_regexp_source>(chunk: Chunk, sep: Sep): $mol_regexp<[$mol_regexp<[[Chunk], Sep] extends infer T ? T extends [[Chunk], Sep] ? T extends $mol_regexp_source[] ? $mol_type_merge<$mol_type_intersect<{ [key in Extract<keyof T, number>]: $mol_regexp_groups<T[key]>; }[Extract<keyof T, number>]>> : T extends RegExp ? Record<string, string> extends NonNullable<NonNullable<ReturnType<T["exec"]>>["groups"]> ? {} : NonNullable<NonNullable<ReturnType<T["exec"]>>["groups"]> : T extends {
             readonly [x: string]: $mol_regexp_source;
         } ? $mol_type_merge<$mol_type_intersect<{ [key_1 in keyof T]: $mol_type_merge<Omit<{ readonly [k in Extract<keyof T, string>]: string; }, key_1> & { readonly [k_1 in key_1]: T[key_1] extends string ? T[key_1] : string; } & $mol_regexp_groups<T[key_1]>>; }[keyof T]>> : never : never : never>, Chunk] extends infer T_1 ? T_1 extends [$mol_regexp<[[Chunk], Sep] extends infer T_2 ? T_2 extends [[Chunk], Sep] ? T_2 extends $mol_regexp_source[] ? $mol_type_merge<$mol_type_intersect<{ [key_4 in Extract<keyof T_2, number>]: $mol_regexp_groups<T_2[key_4]>; }[Extract<keyof T_2, number>]>> : T_2 extends RegExp ? Record<string, string> extends NonNullable<NonNullable<ReturnType<T_2["exec"]>>["groups"]> ? {} : NonNullable<NonNullable<ReturnType<T_2["exec"]>>["groups"]> : T_2 extends {
@@ -998,14 +1259,23 @@ declare namespace $ {
         } ? $mol_type_merge<$mol_type_intersect<{ [key_5 in keyof T_2]: $mol_type_merge<Omit<{ readonly [k in Extract<keyof T_2, string>]: string; }, key_5> & { readonly [k_1 in key_5]: T_2[key_5] extends string ? T_2[key_5] : string; } & $mol_regexp_groups<T_2[key_5]>>; }[keyof T_2]>> : never : never : never>, Chunk] ? T_1 extends $mol_regexp_source[] ? $mol_type_merge<$mol_type_intersect<{ [key_2 in Extract<keyof T_1, number>]: $mol_regexp_groups<T_1[key_2]>; }[Extract<keyof T_1, number>]>> : T_1 extends RegExp ? Record<string, string> extends NonNullable<NonNullable<ReturnType<T_1["exec"]>>["groups"]> ? {} : NonNullable<NonNullable<ReturnType<T_1["exec"]>>["groups"]> : T_1 extends {
             readonly [x: string]: $mol_regexp_source;
         } ? $mol_type_merge<$mol_type_intersect<{ [key_3 in keyof T_1]: $mol_type_merge<Omit<{ readonly [k in Extract<keyof T_1, string>]: string; }, key_3> & { readonly [k_1 in key_3]: T_1[key_3] extends string ? T_1[key_3] : string; } & $mol_regexp_groups<T_1[key_3]>>; }[keyof T_1]>> : never : never : never>;
+        /** Makes regexp that non-greedy repeats this pattern from min to max count */
         static repeat<Source extends $mol_regexp_source>(source: Source, min?: number, max?: number): $mol_regexp<$mol_regexp_groups<Source>>;
+        /** Makes regexp that greedy repeats this pattern from min to max count */
         static repeat_greedy<Source extends $mol_regexp_source>(source: Source, min?: number, max?: number): $mol_regexp<$mol_regexp_groups<Source>>;
+        /** Makes regexp that match any of options */
         static vary<Sources extends readonly $mol_regexp_source[]>(sources: Sources, flags?: string): $mol_regexp<$mol_regexp_groups<Sources[number]>>;
+        /** Makes regexp that allow absent of this pattern */
         static optional<Source extends $mol_regexp_source>(source: Source): $mol_regexp<$mol_regexp_groups<Source>>;
+        /** Makes regexp that look ahead for pattern */
         static force_after(source: $mol_regexp_source): $mol_regexp<Record<string, string>>;
+        /** Makes regexp that look ahead for pattern */
         static forbid_after(source: $mol_regexp_source): $mol_regexp<Record<string, string>>;
+        /** Converts some js values to regexp */
         static from<Source extends $mol_regexp_source>(source: Source, { ignoreCase, multiline }?: Partial<Pick<RegExp, 'ignoreCase' | 'multiline'>>): $mol_regexp<$mol_regexp_groups<Source>>;
+        /** Makes regexp which includes only unicode category */
         static unicode_only(...category: $mol_unicode_category): $mol_regexp<Record<string, string>>;
+        /** Makes regexp which excludes unicode category */
         static unicode_except(...category: $mol_unicode_category): $mol_regexp<Record<string, string>>;
         static char_range(from: number, to: number): $mol_regexp<{}>;
         static char_only(...allowed: readonly [$mol_regexp_source, ...$mol_regexp_source[]]): $mol_regexp<{}>;
@@ -1120,6 +1390,10 @@ declare namespace $ {
     interface $mol_locale_dict {
         [key: string]: string;
     }
+    /**
+     * Localisation in $mol framework
+     * @see https://mol.hyoo.ru/#!section=docs/=s5aqnb_odub8l
+     */
     class $mol_locale extends $mol_object {
         static lang_default(): string;
         static lang(next?: string): string;
@@ -1139,6 +1413,9 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * Fails if `Actual` type is not subtype of `Expected`.
+     */
     type $mol_type_enforce<Actual extends Expected, Expected> = Actual;
 }
 
@@ -1178,21 +1455,54 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /**
+     * # Generic Graph model
+     * - Supports any type of Nodes and Edges.
+     * - All links are ordered, but this may be ignored.
+     * - Multigraph supported using arrays of Edges.
+     * - Hypergraph supported by reusing same Edge on set of links.
+     * - Ubergraph supported using Edges as Nodes to.
+     **/
     class $mol_graph<Node, Edge> {
+        /** All registered Nodes */
         nodes: Set<Node>;
+        /** Edges for Nodes pairs (from-to-edge) */
         edges_out: Map<Node, Map<Node, Edge>>;
+        /** Edges for Nodes pairs (to-from-edge) */
         edges_in: Map<Node, Map<Node, Edge>>;
+        /** Full connect two Nodes */
         link(from: Node, to: Node, edge: Edge): void;
+        /** Full disconnect two Nodes */
         unlink(from: Node, to: Node): void;
+        /** Forward connect two Nodes */
         link_out(from: Node, to: Node, edge: Edge): void;
+        /** Backward connect two Nodes */
         link_in(to: Node, from: Node, edge: Edge): void;
+        /** Return any Edge for two Nodes or null */
         edge(from: Node, to: Node): NonNullable<Edge> | null;
+        /** Return output Edge for two Nodes or null */
         edge_out(from: Node, to: Node): NonNullable<Edge> | null;
+        /** Return input Edge for two Nodes or null */
         edge_in(to: Node, from: Node): NonNullable<Edge> | null;
+        /** Cut cycles at lowest priority of Edges */
         acyclic(get_weight: (edge: Edge) => number): void;
+        /** Topoligical ordered set of all Nodes for acyclic graph */
         get sorted(): Set<Node>;
+        /** All Nodes which don't have input Edges */
         get roots(): Node[];
+        /**
+         * Nodes depth statistics for acyclic graph
+         * @example
+         * graph.depth_stat( Math.min )
+         * graph.depth_stat( Math.max )
+         **/
         nodes_depth(select: (left: number, right: number) => number): Map<Node, number>;
+        /**
+         * Depth's Nodes statistics for acyclic graph
+         * @example
+         * graph.depth_nodes( Math.min )
+         * graph.depth_nodes( Math.max )
+         **/
         depth_nodes(select: (left: number, right: number) => number): Node[][];
     }
 }
@@ -1555,6 +1865,10 @@ declare namespace $ {
         socket(): import("ws").Server<typeof import("ws").default, typeof import("node:http").IncomingMessage>;
         start(): import("ws").Server<typeof import("ws").default, typeof import("node:http").IncomingMessage>;
         protected bundles_count(reset?: null): number;
+        /**
+         * Держать в памяти собранные бандлы плохо, т.к. gc их может долго не утилизировать и node сожрет память и упадет.
+         * Логичнее удалять отложенно, после того как reload-сокет отписался от пути и повторно не подписался.
+         */
         protected bundles_keep(): void;
         protected path_bundles: Record<string, Set<string>>;
         protected path_doubted: Set<string>;