lib0 1.0.0-rc.21 → 1.0.0-rc.23

package/dist/array.d.ts

@@ -20,11 +20,11 @@ export function every<ARR extends ArrayLike<any>>(arr: ARR, f: ARR extends Array
 export function some<ARR extends ArrayLike<any>>(arr: ARR, f: ARR extends ArrayLike<infer S> ? ((value: S, index: number, arr: ARR) => boolean) : never): boolean;
 export function equalFlat<ELEM>(a: ArrayLike<ELEM>, b: ArrayLike<ELEM>): boolean;
 export function flatten<ELEM>(arr: Array<Array<ELEM>>): Array<ELEM>;
-export function unfold<T_1>(len: number, f: (arg0: number, arg1: Array<T_1>) => T_1): Array<T_1>;
-export function fold<T_1, RESULT>(arr: Array<T_1>, seed: RESULT, folder: (arg0: RESULT, arg1: T_1, arg2: number) => RESULT): RESULT;
+export function unfold<T_1>(len: number, f: (index: number, arr: Array<T_1>) => T_1): Array<T_1>;
+export function fold<T_1, RESULT>(arr: Array<T_1>, seed: RESULT, folder: (acc: RESULT, val: T_1, index: number) => RESULT): RESULT;
 export function isArray(o: any): o is any[];
 export function unique<T_1>(arr: Array<T_1>): Array<T_1>;
-export function uniqueBy<T_1, M>(arr: ArrayLike<T_1>, mapper: (arg0: T_1) => M): Array<T_1>;
-export function map<ARR extends ArrayLike<any>, MAPPER extends (arg0: ARR extends ArrayLike<infer T_1> ? T_1 : never, arg1: number, arg2: ARR) => any>(arr: ARR, mapper: MAPPER): Array<MAPPER extends (...args: any[]) => infer M ? M : never>;
+export function uniqueBy<T_1, M>(arr: ArrayLike<T_1>, mapper: (val: T_1) => M): Array<T_1>;
+export function map<ARR extends ArrayLike<any>, MAPPER extends (val: ARR extends ArrayLike<infer T_1> ? T_1 : never, index: number, arr: ARR) => any>(arr: ARR, mapper: MAPPER): Array<MAPPER extends ((...args: Array<any>) => infer M) ? M : never>;
 export function bubblesortItem<T_1>(arr: Array<T_1>, i: number, compareFn: (a: T_1, b: T_1) => number): number;
 //# sourceMappingURL=array.d.ts.map

package/dist/broadcastchannel.d.ts

@@ -1,8 +1,8 @@
-export function subscribe(room: string, f: (arg0: any, arg1: any) => any): (arg0: any, arg1: any) => any;
-export function unsubscribe(room: string, f: (arg0: any, arg1: any) => any): boolean;
+export function subscribe(room: string, f: (data: any, origin: any) => any): (data: any, origin: any) => any;
+export function unsubscribe(room: string, f: (data: any, origin: any) => any): boolean;
 export function publish(room: string, data: any, origin?: any): void;
 export type Channel = {
-    subs: Set<(arg0: any, arg1: any) => any>;
+    subs: Set<(data: any, origin: any) => any>;
     bc: any;
 };
 //# sourceMappingURL=broadcastchannel.d.ts.map

package/dist/decoding.d.ts

@@ -58,13 +58,13 @@ export function readAny(decoder: Decoder): any;
 export class RleDecoder<T> extends Decoder<ArrayBufferLike> {
     /**
      * @param {Uint8Array} uint8Array
-     * @param {function(Decoder):T} reader
+     * @param {(decoder: Decoder) => T} reader
      */
-    constructor(uint8Array: Uint8Array, reader: (arg0: Decoder) => T);
+    constructor(uint8Array: Uint8Array, reader: (decoder: Decoder) => T);
     /**
      * The reader
      */
-    reader: (arg0: Decoder) => T;
+    reader: (decoder: Decoder) => T;
     /**
      * Current state
      * @type {T|null}

package/dist/delta/delta.d.ts

@@ -110,10 +110,6 @@ export class TextOp extends list.ListNode {
      * @type {string?}
      */
     _fingerprint: string | null;
-    /**
-     * @param {string} newVal
-     */
-    _updateInsert(newVal: string): void;
     /**
      * @return {'insert'}
      */
@@ -175,10 +171,6 @@ export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
      * @type {string?}
      */
     _fingerprint: string | null;
-    /**
-     * @param {ArrayContent} _newVal
-     */
-    _updateInsert(_newVal: ArrayContent): void;
     /**
      * @return {'insert'}
      */

package/dist/delta/rdt/dom.d.ts

@@ -28,16 +28,9 @@ export type DomDelta = delta.Delta<DomConf>;
 import * as delta from '../delta.js';
 import * as s from '../../schema.js';
 /**
- * The {@link delta.DeltaConf} of the deltas a {@link DomRDT} produces/consumes (see {@link $domDelta}).
- *
- * @typedef {{ name: string, attrs: { [key:string]: string }, text: true, recursiveChildren: true }} DomConf
- */
-/**
- * @typedef {delta.Delta<DomConf>} DomDelta
- */
-/**
- * An RDT backed by a live DOM subtree. DOM mutations observed via `MutationObserver` are diffed
- * against the last-known state and emitted as deltas; incoming deltas are applied back onto the DOM.
+ * An RDT backed by a live DOM subtree. DOM mutations observed via `MutationObserver` reconcile the
+ * mirror incrementally (re-reading only changed paths, reusing unchanged subtrees by reference) and the
+ * resulting minimal diff is emitted as a delta; incoming deltas are applied back onto the DOM.
  *
  * @implements {RDT<DomConf>}
  * @extends {ObservableV2<{ delta: (delta: delta.Delta<DomConf>, origin: any) => void, destroy: (rdt: DomRDT) => void }>}
@@ -56,24 +49,22 @@ declare class DomRDT extends ObservableV2<{
     $delta: Schema<DomDelta>;
     observedNode: Element;
     /**
-     * Last-known DOM state. The observe path diffs the live DOM against this to compute the change to
-     * emit, then advances it; `applyDelta` re-syncs it after mutating the DOM.
+     * Maps each observed DOM node to its mirror delta node in {@link DomRDT#_state}. A {@link reconcile}
+     * reuses an unchanged subtree by reference (skipping its DOM read) via this map; entries for removed
+     * nodes are reclaimed automatically.
      *
-     * @type {DomDelta}
+     * @type {WeakMap<Node, DomDelta>}
      */
-    _state: DomDelta;
-    observer: MutationObserver;
+    _nodes: WeakMap<Node, DomDelta>;
     /**
-     * Pull the local DOM changes accumulated since the last sync as a delta (by diffing the live DOM
-     * against `_state`), advancing `_state` to the current DOM.
+     * The live delta mirror of the observed subtree, maintained incrementally. A reconcile rebuilds only
+     * the changed paths and swaps this whole root (see {@link pull}); it is never mutated in place, so a
+     * mirror handed out by {@link DomRDT#delta} stays a valid immutable snapshot.
      *
-     * @return {DomDelta}
-     */
-    _pull(): DomDelta;
-    /**
-     * @param {MutationRecord[]} mutations
+     * @type {DomDelta}
      */
-    _mutationHandler: (mutations: MutationRecord[]) => void;
+    _state: DomDelta;
+    observer: MutationObserver;
     /**
      * Apply a foreign delta onto the DOM.
      *
@@ -87,11 +78,14 @@ declare class DomRDT extends ObservableV2<{
      * listeners can recognise (and skip) their own changes — see {@link RDT} “Origins”. Defaults to `null`
      * (an anonymous/local change).
      * @return {delta.DeltaBuilder<DomConf> | null} the rebased local change (`b`), or `null` when there
-     * were no concurrent edits
+     * were no concurrent edits. A binding maps a returned fix back onto the other side with the
+     * `correction` origin (see `../rdt.js`)
      */
     applyDelta(d: delta.Delta<DomConf>, origin?: any): delta.DeltaBuilder<DomConf> | null;
     /**
-     * The current state as a delta: an "insert everything" delta describing the observed subtree.
+     * The current state as a delta: the live mirror ({@link DomRDT#_state}), an "insert everything" delta
+     * describing the observed subtree. A shared read snapshot — consumers clone before mutating (see
+     * {@link RDT}); the mirror is never mutated in place, so a returned snapshot stays valid.
      *
      * @return {delta.Delta<DomConf>}
      */

package/dist/delta/rdt.d.ts

@@ -33,6 +33,12 @@ export { deltaRDT } from "./rdt/delta.js";
  * it just received. The `origin` argument to `applyDelta` is optional and defaults to `null` (an
  * anonymous/local change); the emitted event always carries whatever value was supplied.
  *
+ * A {@link Binding} distinguishes the two kinds of changes it produces. An ordinary change mapped
+ * over from the other side carries the binding itself as its origin. A change that adjusts a side's
+ * own earlier change after the fact — a fix returned by the opposite RDT transformed back, or a
+ * transformer self-heal — carries {@link correctionOrigin}, so a consumer that applied a delta can recognise
+ * that (part of) its change was reverted or amended.
+ *
  * ## `Delta` vs `DeltaBuilder`
  *
  * The interface is parameterized by a {@link import('./delta.js').DeltaConf DeltaConf} (like a
@@ -62,6 +68,18 @@ export { deltaRDT } from "./rdt/delta.js";
  * @type {Schema<RDT<any>>}
  */
 export const $rdt: Schema<RDT<any>>;
+/**
+ * The {@link RDT origin} carried by every change a {@link Binding} applies as an after-the-fact
+ * adjustment to a side's own change: a fix returned by the opposite RDT's `applyDelta` transformed back
+ * onto the side that produced the original change, a transformer self-heal (including during the
+ * initial-state sync), and every later round of the fix-convergence loop (fixes of fixes). A "fix"
+ * covers invariant corrections as well as rebased concurrent edits (see `./rdt/dom.js`). An ordinary
+ * mapped change carries the binding itself instead — see the "Origins" section of {@link RDT}. The
+ * value is a plain string, so `origin === 'correction'` works without importing this constant.
+ *
+ * @type {'correction'}
+ */
+export const correctionOrigin: "correction";
 /**
  * @typedef {object} BindOptions
  * @property {delta.DiffOptions['compare']} [diffCompare] **Experimental** (may be changed or removed
@@ -144,6 +162,12 @@ export type Schema<T> = import("../schema.js").Schema<T>;
  * it just received. The `origin` argument to `applyDelta` is optional and defaults to `null` (an
  * anonymous/local change); the emitted event always carries whatever value was supplied.
  *
+ * A {@link Binding} distinguishes the two kinds of changes it produces. An ordinary change mapped
+ * over from the other side carries the binding itself as its origin. A change that adjusts a side's
+ * own earlier change after the fact — a fix returned by the opposite RDT transformed back, or a
+ * transformer self-heal — carries {@link correctionOrigin}, so a consumer that applied a delta can recognise
+ * that (part of) its change was reverted or amended.
+ *
  * ## `Delta` vs `DeltaBuilder`
  *
  * The interface is parameterized by a {@link import ('./delta.js').DeltaConf DeltaConf} (like a

package/dist/diff.d.ts

@@ -1,6 +1,6 @@
 export function simpleDiffString(a: string, b: string): SimpleDiff<string>;
 export function simpleDiff(a: string, b: string): SimpleDiff<string>;
-export function simpleDiffArray<T>(a: Array<T>, b: Array<T>, compare?: (arg0: T, arg1: T) => boolean): SimpleDiff<Array<T>>;
+export function simpleDiffArray<T>(a: Array<T>, b: Array<T>, compare?: (a: T, b: T) => boolean): SimpleDiff<Array<T>>;
 export function simpleDiffStringWithCursor(a: string, b: string, cursor: number): {
     index: number;
     remove: number;

package/dist/encoding.d.ts

@@ -10,7 +10,7 @@ export class Encoder {
     bufs: Array<Uint8Array>;
 }
 export function createEncoder(): Encoder;
-export function encode(f: (arg0: Encoder) => void): Uint8Array<ArrayBuffer>;
+export function encode(f: (encoder: Encoder) => void): Uint8Array<ArrayBuffer>;
 export function length(encoder: Encoder): number;
 export function hasContent(encoder: Encoder): boolean;
 export function toUint8Array(encoder: Encoder): Uint8Array<ArrayBuffer>;
@@ -56,13 +56,13 @@ export function writeAny(encoder: Encoder, data: AnyEncodable): void;
  */
 export class RleEncoder<T> extends Encoder {
     /**
-     * @param {function(Encoder, T):void} writer
+     * @param {(encoder: Encoder, value: T) => void} writer
      */
-    constructor(writer: (arg0: Encoder, arg1: T) => void);
+    constructor(writer: (encoder: Encoder, value: T) => void);
     /**
      * The writer
      */
-    w: (arg0: Encoder, arg1: T) => void;
+    w: (encoder: Encoder, value: T) => void;
     /**
      * Current state
      * @type {T|null}

package/dist/environment.common.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Environment detection primitives shared by `environment.js` and `storage.js`.
+ *
+ * Internal module (not exported in `package.json`) — it exists so that `storage.js` can check
+ * `isBrowser` without importing `environment.js`, which imports `storage.js` (circular import).
+ */
+export const isNode: boolean;
+/**
+ * True iff this script is running in deno
+ * @type {boolean}
+ */
+export const isDeno: boolean;
+export const globalScope: any;
+/**
+ * True iff this script is running in a browser-family environment — either a DOM main
+ * thread (`window` + `document`) or a WebWorker / ServiceWorker (a `WorkerGlobalScope`,
+ * which has `btoa`/`atob`/`fetch` but no DOM). Excludes Node and Deno.
+ * @type {boolean}
+ */
+export const isBrowser: boolean;
+//# sourceMappingURL=environment.common.d.ts.map

package/dist/environment.d.ts

@@ -1,10 +1,3 @@
-export const isNode: boolean;
-/**
- * True iff this script is running in deno
- * @type {boolean}
- */
-export const isDeno: boolean;
-export const isBrowser: boolean;
 export const isMac: boolean;
 /**
  * True iff a DOM is available — either a real browser, or Node with a jsdom shim installed (see
@@ -27,5 +20,6 @@ export const production: boolean;
  */
 export const supportsColor: boolean;
 export { globalScope as global };
-declare const globalScope: any;
+import { globalScope } from './environment.common.js';
+export { isNode, isDeno, isBrowser } from "./environment.common.js";
 //# sourceMappingURL=environment.d.ts.map

package/dist/error.d.ts

@@ -1,5 +1,23 @@
 export function create(s: string): Error;
-export function methodUnimplemented(): never;
-export function unexpectedCase(): never;
-export function assert(property: boolean): asserts property is true;
+/**
+ * `@type` (not `@param`/`@return`) is required for the `never` return to affect control-flow
+ * analysis — a call to a never-returning function only terminates a code path if the callee is
+ * declared with an explicit type annotation.
+ *
+ * @throws {Error}
+ * @type {() => never}
+ */
+export const methodUnimplemented: () => never;
+/**
+ * @throws {Error}
+ * @type {() => never}
+ */
+export const unexpectedCase: () => never;
+/**
+ * `@type` (not `@param`/`@return`) is required — an assertion signature only narrows if the
+ * callee is declared with an explicit type annotation.
+ *
+ * @type {(property: boolean) => asserts property is true}
+ */
+export const assert: (property: boolean) => asserts property is true;
 //# sourceMappingURL=error.d.ts.map

package/dist/eventloop.d.ts

@@ -7,7 +7,7 @@ export const Animation: {
         destroy(): void;
     };
 };
-export function animationFrame(cb: (arg0: number) => void): TimeoutObject;
+export function animationFrame(cb: (timestamp: number) => void): TimeoutObject;
 export function idleCallback(cb: Function): TimeoutObject;
 export function createDebouncer(timeout: number, triggerAfter?: number): (cb: ((...args: any) => void) | null) => void;
 export type TimeoutObject = {

package/dist/indexeddb.d.ts

@@ -1,5 +1,5 @@
 export function rtop(request: IDBRequest): Promise<any>;
-export function openDB(name: string, initDB: (arg0: IDBDatabase) => any): Promise<IDBDatabase>;
+export function openDB(name: string, initDB: (db: IDBDatabase) => any): Promise<IDBDatabase>;
 export function deleteDB(name: string): Promise<any>;
 export function createStores(db: IDBDatabase, definitions: Array<Array<string> | Array<string | IDBObjectStoreParameters | undefined>>): void;
 export function transact(db: IDBDatabase, stores: Array<string>, access?: "readwrite" | "readonly"): Array<IDBObjectStore>;
@@ -15,8 +15,8 @@ export function queryFirst(store: IDBObjectStore, query: IDBKeyRange | null, dir
 export function getLastKey(store: IDBObjectStore, range?: IDBKeyRange | null): Promise<any>;
 export function getFirstKey(store: IDBObjectStore, range?: IDBKeyRange | null): Promise<any>;
 export function getAllKeysValues(store: IDBObjectStore, range?: IDBKeyRange, limit?: number): Promise<Array<KeyValuePair>>;
-export function iterate(store: IDBObjectStore, keyrange: IDBKeyRange | null, f: (arg0: any, arg1: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): Promise<void>;
-export function iterateKeys(store: IDBObjectStore, keyrange: IDBKeyRange | null, f: (arg0: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): Promise<void>;
+export function iterate(store: IDBObjectStore, keyrange: IDBKeyRange | null, f: (value: any, key: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): Promise<void>;
+export function iterateKeys(store: IDBObjectStore, keyrange: IDBKeyRange | null, f: (key: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): Promise<void>;
 export function getStore(t: IDBTransaction, store: string): IDBObjectStore;
 export function createIDBKeyRangeBound(lower: any, upper: any, lowerOpen: boolean, upperOpen: boolean): IDBKeyRange;
 export function createIDBKeyRangeUpperBound(upper: any, upperOpen: boolean): IDBKeyRange;

package/dist/indexeddbV2.d.ts

@@ -1,5 +1,5 @@
 export function bindPledge(p: pledge.PledgeInstance<any>, request: IDBRequest): void;
-export function openDB(name: string, initDB: (arg0: IDBDatabase) => any): pledge.PledgeInstance<IDBDatabase>;
+export function openDB(name: string, initDB: (db: IDBDatabase) => any): pledge.PledgeInstance<IDBDatabase>;
 export function deleteDB(name: pledge.Pledge<string>): pledge.PledgeInstance<void>;
 export function createStores(db: IDBDatabase, definitions: Array<Array<string> | Array<string | IDBObjectStoreParameters | undefined>>): void;
 export function transact(db: pledge.Pledge<IDBDatabase>, stores: pledge.Pledge<Array<string>>, access?: "readwrite" | "readonly"): pledge.Pledge<Array<IDBObjectStore>>;
@@ -15,8 +15,8 @@ export function queryFirst(store: IDBObjectStore, query: IDBKeyRange | null, dir
 export function getLastKey(store: IDBObjectStore, range?: IDBKeyRange | null): pledge.PledgeInstance<any>;
 export function getFirstKey(store: IDBObjectStore, range?: IDBKeyRange | null): pledge.PledgeInstance<any>;
 export function getAllKeysValues(store: pledge.Pledge<IDBObjectStore>, range?: pledge.Pledge<IDBKeyRange | undefined>, limit?: pledge.Pledge<number | undefined>): pledge.PledgeInstance<Array<KeyValuePair>>;
-export function iterate(store: pledge.Pledge<IDBObjectStore>, keyrange: pledge.Pledge<IDBKeyRange | null>, f: (arg0: any, arg1: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): pledge.PledgeInstance<any, Error>;
-export function iterateKeys(store: pledge.Pledge<IDBObjectStore>, keyrange: pledge.Pledge<IDBKeyRange | null>, f: (arg0: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): pledge.PledgeInstance<any, Error>;
+export function iterate(store: pledge.Pledge<IDBObjectStore>, keyrange: pledge.Pledge<IDBKeyRange | null>, f: (value: any, key: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): pledge.PledgeInstance<any, Error>;
+export function iterateKeys(store: pledge.Pledge<IDBObjectStore>, keyrange: pledge.Pledge<IDBKeyRange | null>, f: (key: any) => void | boolean | Promise<void | boolean>, direction?: "next" | "prev" | "nextunique" | "prevunique"): pledge.PledgeInstance<any, Error>;
 export function getStore(t: IDBTransaction, store: string): IDBObjectStore;
 export function createIDBKeyRangeBound(lower: any, upper: any, lowerOpen: boolean, upperOpen: boolean): IDBKeyRange;
 export function createIDBKeyRangeUpperBound(upper: any, upperOpen: boolean): IDBKeyRange;

package/dist/iterator.d.ts

@@ -1,5 +1,5 @@
-export function mapIterator<T, R>(iterator: Iterator<T>, f: (arg0: T) => R): IterableIterator<R>;
+export function mapIterator<T, R>(iterator: Iterator<T>, f: (v: T) => R): IterableIterator<R>;
 export function createIterator<T>(next: () => IteratorResult<T>): IterableIterator<T>;
-export function iteratorFilter<T>(iterator: Iterator<T>, filter: (arg0: T) => boolean): IterableIterator<T>;
-export function iteratorMap<T, M>(iterator: Iterator<T>, fmap: (arg0: T) => M): IterableIterator<M | undefined>;
+export function iteratorFilter<T>(iterator: Iterator<T>, filter: (v: T) => boolean): IterableIterator<T>;
+export function iteratorMap<T, M>(iterator: Iterator<T>, fmap: (v: T) => M): IterableIterator<M | undefined>;
 //# sourceMappingURL=iterator.d.ts.map

package/dist/list.d.ts

@@ -23,15 +23,15 @@ export class List<N extends ListNode> {
     len: number;
     toArray(): N[];
     /**
-     * @param {function(N):any} f
+     * @param {(node: N) => any} f
      */
-    forEach(f: (arg0: N) => any): void;
+    forEach(f: (node: N) => any): void;
     /**
      * @template M
-     * @param {function(N):M} f
+     * @param {(node: N) => M} f
      * @return {Array<M>}
      */
-    map<M>(f: (arg0: N) => M): Array<M>;
+    map<M>(f: (node: N) => M): Array<M>;
     [Symbol.iterator](): Generator<N, void, unknown>;
     /**
      * @param {List<any>} other
@@ -48,8 +48,8 @@ export function pushEnd<N extends ListNode>(queue: List<N>, n: N): void;
 export function pushFront<N extends ListNode>(queue: List<N>, n: N): void;
 export function popFront<N extends ListNode>(list: List<N>): N | null;
 export function popEnd<N extends ListNode>(list: List<N>): N | null;
-export function map<N extends ListNode, M>(list: List<N>, f: (arg0: N) => M): Array<M>;
+export function map<N extends ListNode, M>(list: List<N>, f: (node: N) => M): Array<M>;
 export function toArray<N extends ListNode>(list: List<N>): N[];
-export function forEach<N extends ListNode>(list: List<N>, f: (arg0: N) => any): void;
+export function forEach<N extends ListNode>(list: List<N>, f: (node: N) => any): void;
 import * as equalityTrait from './trait/equality.js';
 //# sourceMappingURL=list.d.ts.map

package/dist/logging.common.d.ts

@@ -8,5 +8,5 @@ export const PURPLE: symbol;
 export const ORANGE: symbol;
 export const UNCOLOR: symbol;
 export function computeNoColorLoggingArgs(args: Array<undefined | string | Symbol | Object | number | (() => any)>): Array<string | object | number | undefined>;
-export function createModuleLogger(_print: (...args: any[]) => void, moduleName: string): (...args: any[]) => void;
+export function createModuleLogger(_print: (...args: Array<any>) => void, moduleName: string): (...args: Array<any>) => void;
 //# sourceMappingURL=logging.common.d.ts.map

package/dist/logging.d.ts

@@ -50,6 +50,6 @@ export class VConsole {
     destroy(): void;
 }
 export function createVConsole(dom: Element): VConsole;
-export function createModuleLogger(moduleName: string): (...args: any[]) => void;
+export function createModuleLogger(moduleName: string): (...args: Array<any>) => void;
 export { BOLD, UNBOLD, BLUE, GREY, GREEN, RED, PURPLE, ORANGE, UNCOLOR } from "./logging.common.js";
 //# sourceMappingURL=logging.d.ts.map

package/dist/logging.node.d.ts

@@ -9,6 +9,6 @@ export function groupEnd(): void;
 export function printDom(_createNode: () => Node): void;
 export function printCanvas(canvas: HTMLCanvasElement, height: number): void;
 export function createVConsole(_dom: Element): void;
-export function createModuleLogger(moduleName: string): (...args: any[]) => void;
+export function createModuleLogger(moduleName: string): (...args: Array<any>) => void;
 export { BOLD, UNBOLD, BLUE, GREY, GREEN, RED, PURPLE, ORANGE, UNCOLOR } from "./logging.common.js";
 //# sourceMappingURL=logging.node.d.ts.map

package/dist/map.d.ts

@@ -1,8 +1,8 @@
 export function create(): Map<any, any>;
 export function copy<K, V>(m: Map<K, V>): Map<K, V>;
-export function setIfUndefined<MAP extends Map<any, any>, CF extends MAP extends Map<any, infer V> ? () => V : unknown>(map: MAP, key: MAP extends Map<infer K, any> ? K : unknown, createT: CF): ReturnType<CF>;
-export function map<K, V, R>(m: Map<K, V>, f: (arg0: V, arg1: K) => R): Array<R>;
-export function any<K, V>(m: Map<K, V>, f: (arg0: V, arg1: K) => boolean): boolean;
-export function all<K, V>(m: Map<K, V>, f: (arg0: V, arg1: K) => boolean): boolean;
+export function setIfUndefined<MAP extends Map<any, any>, CF extends MAP extends Map<any, infer V> ? (() => V) : unknown>(map: MAP, key: MAP extends Map<infer K, any> ? K : unknown, createT: CF): ReturnType<CF>;
+export function map<K, V, R>(m: Map<K, V>, f: (value: V, key: K) => R): Array<R>;
+export function any<K, V>(m: Map<K, V>, f: (value: V, key: K) => boolean): boolean;
+export function all<K, V>(m: Map<K, V>, f: (value: V, key: K) => boolean): boolean;
 export type GlobalMap<K, V> = Map<K, V>;
 //# sourceMappingURL=map.d.ts.map

package/dist/object.d.ts

@@ -33,10 +33,10 @@ export const values: {
 };
 export function forEach<V_1>(obj: {
     [k: string]: V_1;
-}, f: (arg0: V_1, arg1: string) => any): void;
+}, f: (value: V_1, key: string) => any): void;
 export function map<R>(obj: {
     [x: string]: any;
-}, f: (arg0: any, arg1: string) => R): Array<R>;
+}, f: (value: any, key: string) => R): Array<R>;
 export function length(obj: {
     [x: string]: any;
 }): number;

package/dist/observable.d.ts

@@ -5,9 +5,9 @@
  * This is basically a (better typed) duplicate of Observable, which will replace Observable in the
  * next release.
  *
- * @template {{[key in keyof EVENTS]: function(...any):void}} EVENTS
+ * @template {{[key in keyof EVENTS]: (...args: Array<any>) => void}} EVENTS
  */
-export class ObservableV2<EVENTS extends { [key in keyof EVENTS]: (...args: any[]) => void; }> {
+export class ObservableV2<EVENTS extends { [key in keyof EVENTS]: (...args: Array<any>) => void; }> {
     /**
      * Some desc.
      * @type {Map<string, Set<any>>}

package/dist/pair.d.ts

@@ -17,6 +17,6 @@ export class Pair<L, R> {
 }
 export function create<L, R>(left: L, right: R): Pair<L, R>;
 export function createReversed<L, R>(right: R, left: L): Pair<L, R>;
-export function forEach<L, R>(arr: Array<Pair<L, R>>, f: (arg0: L, arg1: R) => any): void;
-export function map<L, R, X>(arr: Array<Pair<L, R>>, f: (arg0: L, arg1: R) => X): Array<X>;
+export function forEach<L, R>(arr: Array<Pair<L, R>>, f: (left: L, right: R) => any): void;
+export function map<L, R, X>(arr: Array<Pair<L, R>>, f: (left: L, right: R) => X): Array<X>;
 //# sourceMappingURL=pair.d.ts.map

package/dist/pledge.d.ts

@@ -13,13 +13,13 @@ export class PledgeInstance<Val extends unknown, CancelReason extends unknown =
     _v: Val | CancelReason | null;
     isResolved: boolean;
     /**
-     * @type {Array<function(Val):void> | null}
+     * @type {Array<(val: Val) => void> | null}
      */
-    _whenResolved: Array<(arg0: Val) => void> | null;
+    _whenResolved: Array<(val: Val) => void> | null;
     /**
-     * @type {Array<function(CancelReason):void> | null}
+     * @type {Array<(reason: CancelReason) => void> | null}
      */
-    _whenCanceled: Array<(arg0: CancelReason) => void> | null;
+    _whenCanceled: Array<(reason: CancelReason) => void> | null;
     get isDone(): boolean;
     get isCanceled(): boolean;
     /**
@@ -32,14 +32,14 @@ export class PledgeInstance<Val extends unknown, CancelReason extends unknown =
     cancel(reason: CancelReason): void;
     /**
      * @template R
-     * @param {function(Val):Pledge<R>} f
+     * @param {(val: Val) => Pledge<R>} f
      * @return {PledgeInstance<R>}
      */
-    map<R>(f: (arg0: Val) => Pledge<R>): PledgeInstance<R>;
+    map<R>(f: (val: Val) => Pledge<R>): PledgeInstance<R>;
     /**
-     * @param {function(Val):void} f
+     * @param {(val: Val) => void} f
      */
-    whenResolved(f: (arg0: Val) => void): void;
+    whenResolved(f: (val: Val) => void): void;
     /**
      * @param {(reason: CancelReason) => void} f
      */
@@ -51,8 +51,8 @@ export class PledgeInstance<Val extends unknown, CancelReason extends unknown =
 }
 export function create<T>(): PledgeInstance<T>;
 export function createWithDependencies<V, DEPS extends Array<Pledge<unknown>>>(init: (p: PledgeInstance<V>, ...deps: Resolved<DEPS>) => void, ...deps: DEPS): PledgeInstance<V>;
-export function whenResolved<R>(p: Pledge<R>, f: (arg0: R) => void): void;
-export function whenCanceled<P extends Pledge<unknown>>(p: P, f: P extends PledgeInstance<unknown, infer CancelReason> ? (arg0: CancelReason) => void : (arg0: any) => void): void;
+export function whenResolved<R>(p: Pledge<R>, f: (res: R) => void): void;
+export function whenCanceled<P extends Pledge<unknown>>(p: P, f: P extends PledgeInstance<unknown, infer CancelReason> ? ((reason: CancelReason) => void) : ((reason: any) => void)): void;
 export function map<P, Q>(p: Pledge<P>, f: (r: P) => Q): Pledge<Q>;
 export function all<PS extends PledgeMap>(ps: PS): PledgeInstance<Resolved<PS>>;
 export function coroutine<Result, YieldResults extends unknown>(f: () => Generator<Pledge<YieldResults> | PledgeInstance<YieldResults, any>, Result, any>): PledgeInstance<Result>;

package/dist/promise.d.ts

@@ -1,5 +1,5 @@
-export function create<T>(f: (arg0: PromiseResolve<T>, arg1: (arg0: Error) => void) => any): Promise<T>;
-export function createEmpty(f: (arg0: () => void, arg1: (arg0: Error) => void) => void): Promise<void>;
+export function create<T>(f: (resolve: PromiseResolve<T>, reject: (err: Error) => void) => any): Promise<T>;
+export function createEmpty(f: (resolve: () => void, reject: (err: Error) => void) => void): Promise<void>;
 /**
  * `Promise.all` wait for all promises in the array to resolve and return the result
  * @template {unknown[] | []} PS

package/dist/schema.d.ts

@@ -125,7 +125,7 @@ export class Schema<T> implements equalityTraits.EqualityTrait {
      * Can be useful when defining lambdas: `s.lambda(s.$number, s.$number).expect((n) => n + 1)`
      *
      * @param {T} o
-     * @return {o extends T ? T : never}
+     * @return {T extends T ? T : never}
      */
     expect(o: T): T extends T ? T : never;
     $type: Schema<Schema<any>>;
@@ -564,6 +564,13 @@ export class PatternMatcher<State extends unknown = undefined, Patterns extends
 }
 export function match<State = undefined>(state?: State): PatternMatcher<State extends undefined ? undefined : ReadSchemaUnwrapped<State>>;
 export function random<S>(gen: prng.PRNG, schema: S, fallback?: (gen: prng.PRNG, o: Schema<any>) => any): ReadSchemaUnwrapped<S>;
+export function coerce<S extends Schema<any>>(schema: S): (o: any) => {
+    err: string;
+    result: null;
+} | {
+    err: null;
+    result: Unwrap<S>;
+};
 export type Primitive = string | number | bigint | boolean | null | undefined | symbol;
 export type AnyObject = {
     [k: string | number | symbol]: any;
@@ -593,6 +600,17 @@ export type Pattern<In, Out> = {
     h: (o: In, state?: any) => Out;
 };
 export type PatternMatcherFn<Ps extends Pattern<any, any>, S> = import("./ts.js").UnionToIntersection<Ps extends Pattern<infer In, infer Out> ? [S] extends [undefined] ? (o: In) => Out : (o: In, state: S) => Out : never> & ([S] extends [undefined] ? (o: Ps extends Pattern<infer In, any> ? In : never) => (Ps extends Pattern<any, infer Out> ? Out : never) : (o: Ps extends Pattern<infer In, any> ? In : never, state: S) => (Ps extends Pattern<any, infer Out> ? Out : never));
+/**
+ * Carries the reason of a failed coercion out of the recursion.
+ */
+export type _CoerceCtx = {
+    err: string;
+};
+/**
+ * A compiled coercer. Returns the coerced value, or `_failed` after writing the reason to
+ * `ctx.err`.
+ */
+export type _Coercer = (o: any, path: string, ctx: _CoerceCtx) => any;
 import * as equalityTraits from './trait/equality.js';
 /**
  * @extends Schema<never>

package/dist/sort.d.ts

@@ -1,4 +1,4 @@
-export function _insertionSort<T>(arr: Array<T>, lo: number, hi: number, compare: (arg0: T, arg1: T) => number): void;
-export function insertionSort<T>(arr: Array<T>, compare: (arg0: T, arg1: T) => number): void;
-export function quicksort<T>(arr: Array<T>, compare: (arg0: T, arg1: T) => number): void;
+export function _insertionSort<T>(arr: Array<T>, lo: number, hi: number, compare: (a: T, b: T) => number): void;
+export function insertionSort<T>(arr: Array<T>, compare: (a: T, b: T) => number): void;
+export function quicksort<T>(arr: Array<T>, compare: (a: T, b: T) => number): void;
 //# sourceMappingURL=sort.d.ts.map

package/dist/storage.d.ts

@@ -2,12 +2,12 @@
  * This is basically localStorage in browser, or a polyfill in nodejs
  */
 export const varStorage: any;
-export function onChange(eventHandler: (arg0: {
+export function onChange(eventHandler: (e: {
     key: string;
     newValue: string;
     oldValue: string;
 }) => void): true | void;
-export function offChange(eventHandler: (arg0: {
+export function offChange(eventHandler: (e: {
     key: string;
     newValue: string;
     oldValue: string;