From cb81893113f9d5ad4d8ef4731838ea5fff863384 Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:29:53 +0400
Subject: [PATCH 1/7] fix: sweep 5 es5

---
 scripts/check-legacy-run.mjs                  |   8 +
 src/_dom/index.ts                             |   2 +-
 src/_helpers/arrayfrom.ts                     |  10 +-
 src/_helpers/assign.ts                        |   5 +-
 src/_helpers/forown.ts                        |   3 +-
 src/_helpers/fromentries.ts                   |  11 +-
 src/binders/html.ts                           |   2 +-
 src/binders/output.ts                         |   2 +-
 src/binders/text.ts                           |   2 +-
 src/class.ts                                  |  16 +-
 .../_definehiddencontentproperty.ts           |   2 +-
 test/legacy/scenario.js                       |  38 +++
 test/spec/regressions/sweep5_es5_spec.js      | 245 ++++++++++++++++++
 13 files changed, 327 insertions(+), 19 deletions(-)
 create mode 100644 test/spec/regressions/sweep5_es5_spec.js

diff --git a/scripts/check-legacy-run.mjs b/scripts/check-legacy-run.mjs
index c4167118..0a632e80 100644
--- a/scripts/check-legacy-run.mjs
+++ b/scripts/check-legacy-run.mjs
@@ -42,6 +42,14 @@ function toIE11(window) {
     'getOwnPropertySymbols',
     'getOwnPropertyDescriptors'
   ]);
+  // ES5's Object.keys: a primitive throws
+  const { keys } = window.Object;
+  window.Object.keys = (object) => {
+    if (object === null || (typeof object !== 'object' && typeof object !== 'function')) {
+      throw new window.TypeError('Object.keys: argument is not an Object');
+    }
+    return keys(object);
+  };
   drop(window.Array, ['from', 'of']);
   drop(window.Array.prototype, [
     'includes',
diff --git a/src/_dom/index.ts b/src/_dom/index.ts
index 9564293d..e0dbb0da 100644
--- a/src/_dom/index.ts
+++ b/src/_dom/index.ts
@@ -29,7 +29,7 @@ const wrapMap: Record<string, [number, string, string]> = {
   thead: [1, '<table>', '</table>'],
   tr: [2, '<table><tbody>', '</tbody></table>'],
   td: [3, '<table><tbody><tr>', '</tr></tbody></table>'],
-  col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
+  col: [2, '<table><colgroup>', '</colgroup></table>'],
   area: [1, '<map>', '</map>']
 };
 wrapMap.optgroup = wrapMap.option;
diff --git a/src/_helpers/arrayfrom.ts b/src/_helpers/arrayfrom.ts
index 88dbb7eb..a52c378c 100644
--- a/src/_helpers/arrayfrom.ts
+++ b/src/_helpers/arrayfrom.ts
@@ -1,8 +1,8 @@
-import toArray from './toarray.js';
-
-// Array.from where the browser has it, so iterables work too; IE 11 takes array-likes only
+// Array.from where the browser has it, so iterables work too; IE 11 takes array-likes only, holes included
 export default function arrayFrom(value: any, mapFn?: (value: any, index: number) => any, thisArg?: any): any[] {
   if (Array.from) return Array.from(value, mapFn as (value: any, index: number) => any, thisArg);
-  const result = toArray(value);
-  return mapFn ? result.map(mapFn, thisArg) : result;
+  const length = Math.max(0, Math.floor(value.length) || 0);
+  const result: any[] = [];
+  for (let i = 0; i < length; i++) result.push(mapFn ? mapFn.call(thisArg, value[i], i) : value[i]);
+  return result;
 }
diff --git a/src/_helpers/assign.ts b/src/_helpers/assign.ts
index 8cce9dd0..58f4f704 100644
--- a/src/_helpers/assign.ts
+++ b/src/_helpers/assign.ts
@@ -5,8 +5,9 @@ const isEnumerable = Object.prototype.propertyIsEnumerable;
 // Object.assign, which IE 11 lacks; symbol keys are copied where the browser has them
 const assign: typeof Object.assign = function assign(target: any) {
   for (let i = 1; i < arguments.length; i++) {
-    const source = arguments[i];
-    if (source !== null && source !== undefined) {
+    if (arguments[i] !== null && arguments[i] !== undefined) {
+      // a primitive is read as an object: IE 11's Object.keys throws on it
+      const source = Object(arguments[i]);
       forEach(Object.keys(source), (key) => {
         target[key] = source[key];
       });
diff --git a/src/_helpers/forown.ts b/src/_helpers/forown.ts
index 3d0e9086..8ad5ba54 100644
--- a/src/_helpers/forown.ts
+++ b/src/_helpers/forown.ts
@@ -1,5 +1,6 @@
 export default function forOwn<T>(obj: Record<string, T>, callback: (value: T, key: string) => void): void {
-  const keys = Object.keys(obj);
+  // Object(): IE 11's Object.keys throws on a primitive
+  const keys = Object.keys(Object(obj));
   const l = keys.length;
   let i = 0;
   let key: string;
diff --git a/src/_helpers/fromentries.ts b/src/_helpers/fromentries.ts
index 9adc8cdf..10628ef4 100644
--- a/src/_helpers/fromentries.ts
+++ b/src/_helpers/fromentries.ts
@@ -1,6 +1,13 @@
-// Object.fromEntries for an array of pairs; IE 11 lacks it
+// Object.fromEntries for an array of pairs; IE 11 lacks it. Defined, not assigned, so "__proto__" stays a key
 export default function fromEntries(entries: [string, any][]): Record<string, any> {
   const result: Record<string, any> = {};
-  for (let i = 0; i < entries.length; i++) result[entries[i][0]] = entries[i][1];
+  for (let i = 0; i < entries.length; i++) {
+    Object.defineProperty(result, entries[i][0], {
+      value: entries[i][1],
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
   return result;
 }
diff --git a/src/binders/html.ts b/src/binders/html.ts
index 996f4eb3..8cde5307 100644
--- a/src/binders/html.ts
+++ b/src/binders/html.ts
@@ -15,7 +15,7 @@ export default function html(mappingFn?: (value: any) => any): Binder {
         this.innerHTML = '';
         this.appendChild(val);
       } else {
-        this.innerHTML = val === null || val === undefined ? '' : `${val}`;
+        this.innerHTML = val === null || val === undefined ? '' : String(val);
       }
     }
   };
diff --git a/src/binders/output.ts b/src/binders/output.ts
index a4d1cfcc..db45594d 100644
--- a/src/binders/output.ts
+++ b/src/binders/output.ts
@@ -9,7 +9,7 @@ export default function output(): Binder {
     },
     setValue(this: HTMLOutputElement, value: any) {
       const property = 'form' in this ? 'value' : 'textContent';
-      this[property] = value === null || value === undefined ? '' : `${value}`;
+      this[property] = value === null || value === undefined ? '' : String(value);
     }
   };
 }
diff --git a/src/binders/text.ts b/src/binders/text.ts
index 725378c7..472f99fe 100644
--- a/src/binders/text.ts
+++ b/src/binders/text.ts
@@ -10,7 +10,7 @@ export default function text(mappingFn?: (value: any) => any): Binder {
     },
     setValue(this: Node, value: any) {
       const val = typeof mappingFn === 'function' ? mappingFn(value) : value;
-      this.textContent = val === null || val === undefined ? '' : `${val}`;
+      this.textContent = val === null || val === undefined ? '' : String(val);
     }
   };
 }
diff --git a/src/class.ts b/src/class.ts
index 6de68032..703dc3f5 100644
--- a/src/class.ts
+++ b/src/class.ts
@@ -70,14 +70,21 @@ function hasReadOnlyPrototype(fn: any): boolean {
   return Object.getOwnPropertyDescriptor(fn, 'prototype')?.writable === false;
 }
 
+// what `new` built `this` for, read the way Babel compiles new.target: a parent called with `apply` from a subclass
+// constructor gets the subclass, so a chain over an ES class works in src/ and in the ES5 build alike
+function newTarget(self: any, Constructor: AnyConstructor | ((...args: any[]) => any)): AnyConstructor | undefined {
+  return self instanceof Constructor ? self.constructor : undefined;
+}
+
 // `constructor() {}` in an object literal is a method, which `new` refuses, and an ES class has a read-only
 // prototype; both get a wrapper
 function toConstructor(fn: (...args: any[]) => any): AnyConstructor {
   if (isConstructor(fn)) {
     if (hasReadOnlyPrototype(fn)) {
-      return function Constructor(...args: any[]) {
-        return Reflect.construct(fn, args, new.target);
+      const Constructor = function Constructor(this: any, ...args: any[]) {
+        return Reflect.construct(fn, args, newTarget(this, Constructor));
       } as unknown as AnyConstructor;
+      return Constructor;
     }
 
     return fn as unknown as AnyConstructor;
@@ -101,9 +108,10 @@ const Class = function Class(this: any, prototype: ClassPrototype, staticProps?:
   } else if (Parent) {
     // like an ES class without a constructor, call the parent constructor with the same arguments
     Constructor = function EmptyConstructor(this: any, ...args: any[]) {
+      const target = newTarget(this, Constructor);
       // a plain function parent runs on `this`, so `Child.call(this)` from a subclass constructor works too
-      return new.target && hasReadOnlyPrototype(Parent) && hasReflect()
-        ? Reflect.construct(Parent, args, new.target)
+      return target && hasReadOnlyPrototype(Parent) && hasReflect()
+        ? Reflect.construct(Parent, args, target)
         : Parent.apply(this, args);
     } as unknown as AnyConstructor;
   } else {
diff --git a/src/parsebindings/_processattribute/_definehiddencontentproperty.ts b/src/parsebindings/_processattribute/_definehiddencontentproperty.ts
index d88c871b..8e1db632 100644
--- a/src/parsebindings/_processattribute/_definehiddencontentproperty.ts
+++ b/src/parsebindings/_processattribute/_definehiddencontentproperty.ts
@@ -39,7 +39,7 @@ export default function defineHiddenContentProperty({ object, keys, text }: Hidd
 
       // replace things like {{x}} by actual values; a function keeps "$&" and the like in a value literal
       for (let i = 0; i < keys.length; i++) {
-        const value = values[i] === null || values[i] === undefined ? '' : `${values[i]}`;
+        const value = values[i] === null || values[i] === undefined ? '' : String(values[i]);
         result = result.replace(regs[keys[i]], () => value);
       }
 
diff --git a/test/legacy/scenario.js b/test/legacy/scenario.js
index a32f102e..cb6f115c 100644
--- a/test/legacy/scenario.js
+++ b/test/legacy/scenario.js
@@ -405,6 +405,44 @@
     equal(list.fill(0, 1).join('-'), '1-0-0', 'fill is its own');
   });
 
+  test('<col> items, Array.from holes, a primitive in instantiate, String(value) in text', function (done) {
+    html('<table><colgroup class="g"></colgroup></table><span class="m"></span>');
+    var cols = new M.Array();
+    cols.itemRenderer = '<col>';
+    M.bindNode(cols, 'container', '.g');
+    cols.push({}, {});
+    equal($('.g').getElementsByTagName('col').length, 2, 'cols rendered');
+    equal(
+      M.Array.from({ length: 3 }, function (_, i) {
+        return i * 2;
+      }).join(),
+      '0,2,4',
+      'Array.from range'
+    );
+    var Point = function (data) {
+      this.d = data;
+    };
+    var app = {};
+    M.instantiate(app, 'p', Point);
+    app.p = { a: 1 };
+    app.p = 5;
+    equal(app.p.a, 1, 'instantiate keeps the instance');
+    var price = {
+      valueOf: function () {
+        return 42;
+      },
+      toString: function () {
+        return '$42.00';
+      }
+    };
+    M.bindNode(app, 'price', '.m', binders.text());
+    app.price = price;
+    later(function () {
+      equal($('.m').textContent, '$42.00', 'text shows toString');
+      done();
+    });
+  });
+
   // runs the cases in order; window.legacyResult holds { passed, failed: [message] } when all are done
   var failed = [];
   var passed = 0;
diff --git a/test/spec/regressions/sweep5_es5_spec.js b/test/spec/regressions/sweep5_es5_spec.js
new file mode 100644
index 00000000..8b7404b9
--- /dev/null
+++ b/test/spec/regressions/sweep5_es5_spec.js
@@ -0,0 +1,245 @@
+import Class from 'src/class';
+import MatreshkaArray from 'src/array';
+import MatreshkaObject from 'src/object';
+import arrayFrom from 'src/_helpers/arrayfrom';
+import assign from 'src/_helpers/assign';
+import forOwn from 'src/_helpers/forown';
+import fromEntries from 'src/_helpers/fromentries';
+import bindNode from 'src/bindnode';
+import instantiate from 'src/instantiate';
+import parseBindings from 'src/parsebindings';
+import { html, output, text } from 'src/binders';
+import { parseHTML } from 'src/_dom';
+
+// sweep 5, the ES5 build: each case also runs against dist/ (npm run test:dist), where Babel compiled the code for IE 11
+const without = (object, names, fn) => {
+  const saved = names.map((name) => Object.getOwnPropertyDescriptor(object, name));
+  for (const name of names) {
+    Object.defineProperty(object, name, { value: undefined, configurable: true, writable: true });
+  }
+  try {
+    return fn();
+  } finally {
+    names.forEach((name, i) => {
+      if (saved[i]) Object.defineProperty(object, name, saved[i]);
+      else delete object[name];
+    });
+  }
+};
+
+const withoutTemplate = (fn) => {
+  const { createElement } = document;
+  document.createElement = function (name) {
+    return createElement.call(this, name === 'template' ? 'x-template' : name);
+  };
+  try {
+    return fn();
+  } finally {
+    document.createElement = createElement;
+  }
+};
+
+// IE 11's Object.keys is ES5's: a primitive throws
+const withES5Keys = (fn) => {
+  const { keys } = Object;
+  Object.keys = (object) => {
+    if (object === null || (typeof object !== 'object' && typeof object !== 'function')) {
+      throw new TypeError('Object.keys: argument is not an Object');
+    }
+    return keys(object);
+  };
+  try {
+    return fn();
+  } finally {
+    Object.keys = keys;
+  }
+};
+
+const names = (nodes) => nodes.map((node) => node.nodeName);
+
+describe('sweep 5 ES5: parseHTML without <template>', () => {
+  it('gives the same nodes as <template> for every wrapped tag', () => {
+    const tags = ['option', 'optgroup', 'legend', 'thead', 'tbody', 'tfoot', 'colgroup', 'caption'];
+    const markup = tags.concat(['tr', 'td', 'th', 'col', 'area']).map((tag) => `<${tag}></${tag}>`);
+    markup.push('<col>', '<col><col>', '<COL span="2">');
+    const expected = markup.map((item) => names(parseHTML(item)));
+    expect(withoutTemplate(() => markup.map((item) => names(parseHTML(item))))).toEqual(expected);
+    expect(withoutTemplate(() => names(parseHTML('<col><col>')))).toEqual(['COL', 'COL']);
+  });
+
+  it('a Matreshka.Array renders <col> items into a colgroup', () => {
+    const colgroup = document.createElement('colgroup');
+    const count = withoutTemplate(() => {
+      const list = new MatreshkaArray();
+      list.itemRenderer = '<col>';
+      list.bindNode('container', colgroup);
+      list.push({}, {});
+      return colgroup.children.length;
+    });
+    expect(count).toBe(2);
+  });
+});
+
+// a value whose valueOf and toString differ, as a date or a money class has
+const money = () => ({ valueOf: () => 42, toString: () => '$42.00' });
+const settle = () => new Promise((resolve) => setTimeout(resolve, 50));
+
+describe('sweep 5 ES5: a shown value is String(value)', () => {
+  it('binders.text, binders.html and binders.output', async () => {
+    const nodes = ['span', 'span', 'output'].map((name) => document.createElement(name));
+    const object = {};
+    bindNode(object, 'a', nodes[0], text());
+    bindNode(object, 'b', nodes[1], html());
+    bindNode(object, 'c', nodes[2], output());
+    object.a = money();
+    object.b = money();
+    object.c = money();
+    await settle();
+    expect([nodes[0].textContent, nodes[1].innerHTML, nodes[2].value]).toEqual(['$42.00', '$42.00', '$42.00']);
+  });
+
+  it('{{x}} in text and in an attribute', async () => {
+    const node = document.createElement('div');
+    node.innerHTML = '<a title="price {{x}}">{{x}}</a>';
+    const object = {};
+    parseBindings(object, node);
+    object.x = money();
+    await settle();
+    expect([node.firstChild.getAttribute('title'), node.firstChild.textContent]).toEqual(['price $42.00', '$42.00']);
+  });
+});
+
+describe('sweep 5 ES5: arrayFrom without Array.from', () => {
+  it('visits every index, holes included', () => {
+    const result = without(Array, ['from'], () => [
+      arrayFrom({ length: 3 }, (_, i) => i),
+      arrayFrom({ length: 2 }),
+      arrayFrom({ length: 3, 0: 1, 2: 3 }),
+      arrayFrom({}),
+      arrayFrom({ length: -1 }),
+      arrayFrom({ length: 2.5, 0: 'a', 1: 'b' }),
+      arrayFrom(
+        { length: 2, 0: 1, 1: 2 },
+        function (x) {
+          return x * this.k;
+        },
+        { k: 10 }
+      )
+    ]);
+    expect(result).toEqual([[0, 1, 2], [undefined, undefined], [1, undefined, 3], [], [], ['a', 'b'], [10, 20]]);
+    expect(1 in result[1] && 1 in result[2]).toBe(true);
+  });
+
+  it('Matreshka.Array.from({ length: 3 }, (_, i) => i * 2)', () => {
+    const items = without(Array, ['from'], () => MatreshkaArray.from({ length: 3 }, (_, i) => i * 2).toJSON());
+    expect(items).toEqual([0, 2, 4]);
+  });
+});
+
+describe('sweep 5 ES5: a data key named __proto__', () => {
+  it('fromEntries keeps it as an own key', () => {
+    const result = fromEntries([
+      ['__proto__', { x: 1 }],
+      ['a', 2]
+    ]);
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+    expect(Object.keys(result)).toEqual(['__proto__', 'a']);
+    expect(Object.getOwnPropertyDescriptor(result, '__proto__')).toEqual({
+      value: { x: 1 },
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  });
+
+  it('setData(aMatreshkaObject) keeps it', () => {
+    const source = new MatreshkaObject(JSON.parse('{"__proto__":{"x":1},"a":2}'));
+    const target = new MatreshkaObject();
+    target.setData(source);
+    expect(target.keys()).toEqual(['__proto__', 'a']);
+    // biome-ignore lint/suspicious/noProto: the data key, an own accessor
+    expect(target.__proto__).toEqual({ x: 1 });
+    expect(Object.getPrototypeOf(target)).toBe(MatreshkaObject.prototype);
+  });
+
+  it('setData("__proto__", v, { replaceData: true }) removes only the other keys', () => {
+    const object = new MatreshkaObject(JSON.parse('{"__proto__":1,"a":2}'));
+    const removed = [];
+    object.on('remove', (evt) => removed.push(evt.key));
+    object.setData('__proto__', 3, { replaceData: true });
+    expect(removed).toEqual(['a']);
+    expect(object.keys()).toEqual(['__proto__']);
+  });
+});
+
+describe('sweep 5 ES5: a Class chain over an ES class', () => {
+  class Base {
+    constructor(x) {
+      this.x = x;
+    }
+  }
+
+  it('Class({ extends: Class({ extends: Base }) })', () => {
+    const A = Class({ extends: Base });
+    const B = Class({ extends: A });
+    const b = new B(1);
+    expect([b.x, b instanceof B, b instanceof A, b instanceof Base, b.constructor]).toEqual([1, true, true, true, B]);
+    expect(new A(2).constructor).toBe(A);
+  });
+
+  it('a subclass of a Class whose constructor is an ES class', () => {
+    const A = Class({ constructor: Base });
+    const B = Class({ extends: A });
+    const b = new B(2);
+    expect([b.x, b instanceof B, b instanceof A]).toEqual([2, true, true]);
+  });
+
+  it('called on another object, a plain function parent runs on it', () => {
+    const A = Class({
+      extends: function Parent() {
+        this.p = 1;
+      }
+    });
+    const object = {};
+    A.call(object);
+    expect(object.p).toBe(1);
+  });
+
+  it('an ES class that extends the chain', () => {
+    const A = Class({ extends: Base });
+    const B = Class({ extends: A });
+    class C extends B {}
+    const c = new C(3);
+    expect([c.x, c instanceof C, c instanceof Base]).toEqual([3, true, true]);
+  });
+});
+
+describe('sweep 5 ES5: a primitive under the ES5 Object.keys', () => {
+  it('assign skips null and undefined and copies a string as Object.assign does', () => {
+    const native = Object.assign({}, 5, 'ab', true, null, undefined, { c: 1 });
+    expect(withES5Keys(() => assign({}, 5, 'ab', true, null, undefined, { c: 1 }))).toEqual(native);
+  });
+
+  it('forOwn walks a primitive as an object', () => {
+    const seen = [];
+    withES5Keys(() => {
+      forOwn('ab', (value, key) => seen.push(key + value));
+      forOwn(5, (value, key) => seen.push(key + value));
+    });
+    expect(seen).toEqual(['0a', '1b']);
+  });
+
+  it('instantiate takes a number after an object', () => {
+    function C(data) {
+      this.d = data;
+    }
+    const object = {};
+    const a = withES5Keys(() => {
+      instantiate(object, 'x', C);
+      object.x = { a: 1 };
+      object.x = 5;
+      return object.x.a;
+    });
+    expect(a).toBe(1);
+  });
+});

From 50bb7904f0ab2b9af0d35d4668f52636d46fdd01 Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:30:33 +0400
Subject: [PATCH 2/7] fix: sweep 5 events

---
 src/off/_cancelifgone.ts                    |  17 ++
 src/off/_removedomlistener.ts               |  38 ++--
 src/off/_removelistener.ts                  |  20 +-
 src/off/_undelegatelistener.ts              |  22 ++-
 src/off/index.ts                            |  18 +-
 src/on/_adddomlistener.ts                   |  11 +-
 src/once.ts                                 |   4 +
 test/spec/regressions/sweep5_events_spec.js | 203 ++++++++++++++++++++
 8 files changed, 293 insertions(+), 40 deletions(-)
 create mode 100644 src/off/_cancelifgone.ts
 create mode 100644 test/spec/regressions/sweep5_events_spec.js

diff --git a/src/off/_cancelifgone.ts b/src/off/_cancelifgone.ts
new file mode 100644
index 00000000..d9687419
--- /dev/null
+++ b/src/off/_cancelifgone.ts
@@ -0,0 +1,17 @@
+import type { EventEntry } from '../types.js';
+
+// a pending onDebounce call doesn't fire once its listener is gone from the object:
+// from every plain, DOM and delegated event of it
+export default function cancelIfGone(allEvents: Record<string, EventEntry[]>, callback: EventEntry['callback']): void {
+  for (const name in allEvents) {
+    if (
+      allEvents[name].some(
+        ({ callback: existing, info }) =>
+          existing === callback || info.domEvent?.callback === callback || info.delegatedData?.callback === callback
+      )
+    ) {
+      return;
+    }
+  }
+  (callback as { cancel?: () => void }).cancel?.();
+}
diff --git a/src/off/_removedomlistener.ts b/src/off/_removedomlistener.ts
index 8e4e4187..d63ee1ee 100644
--- a/src/off/_removedomlistener.ts
+++ b/src/off/_removedomlistener.ts
@@ -3,16 +3,20 @@ import triggerOne from '../trigger/_triggerone.js';
 import { unlisten } from '../_dom/index.js';
 import forEach from '../_helpers/foreach.js';
 import findDomListeners from '../on/_finddomlisteners.js';
+import { dropOwner, hasOwner, type Owner } from '../on/_owners.js';
+import cancelIfGone from './_cancelifgone.js';
 
-// removes given events from an event list by identity
-function removeEvents(allEvents: Record<string, EventEntry[]>, name: string, eventsToRemove: EventEntry[]): void {
+// drops the owner from the entries of an event list that carry one of given DOM listeners;
+// removes the entries nobody keeps any more
+function dropDomOwner(allEvents: Record<string, EventEntry[]>, name: string, domEvents: any[], owner: Owner): void {
   const events = allEvents[name];
 
   if (!events) {
     return;
   }
 
-  const retain = events.filter((event) => !eventsToRemove.some(({ info }) => info === event.info));
+  // _bind:KEY and _unbind:KEY entries of one listener share its domEvent
+  const retain = events.filter((event) => domEvents.indexOf(event.info.domEvent) === -1 || !dropOwner(event, owner));
 
   if (retain.length) {
     allEvents[name] = retain;
@@ -22,6 +26,7 @@ function removeEvents(allEvents: Record<string, EventEntry[]>, name: string, eve
 }
 
 // removes dom listener from nodes bound to given key
+// a delegation passes its owner and removes only the listener it added, the one nobody else keeps
 export default function removeDomListener(
   object: AnyObject,
   def: ObjectDef,
@@ -29,28 +34,39 @@ export default function removeDomListener(
   eventName: string,
   selector?: string,
   callback?: EventEntry['callback'] | null,
-  context?: any
+  context?: any,
+  owner: Owner = null
 ): AnyObject {
   const { events: allEvents, props } = def;
   const bindEventName = `_bind:${key}`;
-  const found = findDomListeners(allEvents[bindEventName], { eventName, selector, callback, context });
+  const domEvents = findDomListeners(allEvents[bindEventName], { eventName, selector, callback, context }, !!owner)
+    .filter((event) => hasOwner(event, owner))
+    .map((event) => event.info.domEvent);
 
-  if (!found.length) {
+  if (!domEvents.length) {
     return object;
   }
 
-  const bindings = props[key]?.bindings;
+  dropDomOwner(allEvents, bindEventName, domEvents, owner);
+  dropDomOwner(allEvents, `_unbind:${key}`, domEvents, owner);
 
-  removeEvents(allEvents, bindEventName, found);
-  removeEvents(allEvents, `_unbind:${key}`, found);
+  // the listeners still kept by somebody else stay
+  const kept = (allEvents[bindEventName] || []).map((event) => event.info.domEvent);
+  const bindings = props[key]?.bindings;
 
-  forEach(found, (event) => {
-    const { domEvent } = event.info;
+  forEach(domEvents, (domEvent) => {
+    if (kept.indexOf(domEvent) !== -1) {
+      return;
+    }
 
     if (bindings) {
       forEach(bindings, ({ node }) => unlisten(node, domEvent.eventName, domEvent.selector, domEvent.domEventHandler));
     }
 
+    if (!owner) {
+      cancelIfGone(allEvents, domEvent.callback);
+    }
+
     const removeEventData = {
       name: domEvent.name,
       callback: domEvent.callback,
diff --git a/src/off/_removelistener.ts b/src/off/_removelistener.ts
index 6a5dea95..64e2e940 100644
--- a/src/off/_removelistener.ts
+++ b/src/off/_removelistener.ts
@@ -7,14 +7,7 @@ import forOwn from '../_helpers/forown.js';
 import removeDomListener from './_removedomlistener.js';
 import isSameCallback from '../_helpers/issamecallback.js';
 import { dropOwner, hasOwner, type Owner } from '../on/_owners.js';
-
-// a pending onDebounce call doesn't fire once its listener is gone from every name
-function cancelIfGone(allEvents: Record<string, EventEntry[]>, callback: EventEntry['callback']): void {
-  for (const name in allEvents) {
-    if (allEvents[name].some((event) => event.callback === callback)) return;
-  }
-  (callback as { cancel?: () => void }).cancel?.();
-}
+import cancelIfGone from './_cancelifgone.js';
 
 // removes simple event listener from an object
 export default function removeListener(
@@ -31,10 +24,12 @@ export default function removeListener(
   const events = name === undefined ? undefined : allEvents[name];
   const retain: EventEntry[] = [];
   const domEventExecResult = name === undefined ? null : domEventReg.exec(name);
+  // a delegation removes only its own listener, the one it added with this callback and context
+  const owner: Owner = info?.owner ?? null;
 
   if (domEventExecResult) {
     const [, eventName, key = 'sandbox', selector] = domEventExecResult;
-    removeDomListener(object, def, key, eventName, selector, callback, context);
+    removeDomListener(object, def, key, eventName, selector, callback, context, owner);
 
     return true;
   }
@@ -58,8 +53,6 @@ export default function removeListener(
     def.events = Object.create(null);
   } else if (events) {
     const removed: { name: string; callback: EventEntry['callback']; context: any }[] = [];
-    // a delegation removes only its own listener, the one it added with this callback and context
-    const owner: Owner = info?.owner ?? null;
     const matches = (event: EventEntry) =>
       owner
         ? event.callback === callback && event.context === context
@@ -81,7 +74,10 @@ export default function removeListener(
       delete allEvents[name];
     }
 
-    forEach(removed, ({ callback: removedCallback }) => cancelIfGone(allEvents, removedCallback));
+    // a delegation that goes from one object keeps a call pending from another one
+    if (!owner) {
+      forEach(removed, ({ callback: removedCallback }) => cancelIfGone(allEvents, removedCallback));
+    }
 
     // after the list changes: a handler that calls off() or on() for the same name sees the listener gone
     if (name[0] !== '_') {
diff --git a/src/off/_undelegatelistener.ts b/src/off/_undelegatelistener.ts
index 45a6371d..5a6ad6c7 100644
--- a/src/off/_undelegatelistener.ts
+++ b/src/off/_undelegatelistener.ts
@@ -7,6 +7,7 @@ import matchesDelegation, { type Delegation } from '../on/_delegatelistener/_mat
 import { dropOwner, hasOwner, type Owner } from '../on/_owners.js';
 import getProp from '../_helpers/getprop.js';
 import assign from '../_helpers/assign.js';
+import cancelIfGone from './_cancelifgone.js';
 
 // drops the owner from internal events such as _asterisk:add of given delegated listener;
 // returns the delegations nobody keeps any more
@@ -106,23 +107,26 @@ export default function undelegateListener(
       forEach(removed, (data) => undelegateListener(target, path, name, data.callback, data.context, info));
     }
   };
+  let removed: DelegatedData[] = [];
 
   if (key === '*') {
     // remove asterisk events
     if (object.isMatreshkaArray) {
-      const removed = detach('_asterisk:add', '_asterisk:remove');
+      removed = detach('_asterisk:add', '_asterisk:remove');
       // undelegate asterisk events for existing items
-      if (removed.length) {
-        forEach(object as ArrayLike<any>, (item) => undelegateFrom(removed, item));
-      }
+      forEach(object as ArrayLike<any>, (item) => undelegateFrom(removed, item));
     } else if (object.isMatreshkaObject) {
-      const removed = detach('_asterisk:set', '_asterisk:remove');
-      if (removed.length) {
-        object.each((item: any) => undelegateFrom(removed, item));
-      }
+      removed = detach('_asterisk:set', '_asterisk:remove');
+      object.each((item: any) => undelegateFrom(removed, item));
     }
   } else {
     // remove non-asterisk delegated events
-    undelegateFrom(detach(`_change:delegated:${key}`), getProp(object, key));
+    removed = detach(`_change:delegated:${key}`);
+    undelegateFrom(removed, getProp(object, key));
+  }
+
+  // the user's off cancels a pending onDebounce call; a parent's undelegation keeps it: another object may hold it
+  if (!owner) {
+    forEach(removed, (data) => cancelIfGone(allEvents, data.callback));
   }
 }
diff --git a/src/off/index.ts b/src/off/index.ts
index d30b94a3..e96b8d4d 100644
--- a/src/off/index.ts
+++ b/src/off/index.ts
@@ -6,6 +6,7 @@ import forOwn from '../_helpers/forown.js';
 import forEach from '../_helpers/foreach.js';
 import defs from '../_core/defs.js';
 import removeListener from './_removelistener.js';
+import cancelIfGone from './_cancelifgone.js';
 import undelegateListener from './_undelegatelistener.js';
 import triggerOne from '../trigger/_triggerone.js';
 import { unlisten } from '../_dom/index.js';
@@ -129,13 +130,6 @@ function removeUserListeners(object: AnyObject, def: ObjectDef): void {
     triggerOne(object, 'removeevent', removeEventData);
   });
 
-  forEach(retained, ({ events, retain }) => {
-    // a pending onDebounce call doesn't fire after its listener is gone
-    forEach(events, (event) => {
-      if (retain.indexOf(event) === -1) (event.callback as { cancel?: () => void }).cancel?.();
-    });
-  });
-
   forEach(retained, ({ name, events, length, retain }) => {
     // keep listeners which removeevent handlers have added meanwhile
     const current = allEvents[name] === events ? retain.concat(events.slice(length)) : retain;
@@ -147,6 +141,16 @@ function removeUserListeners(object: AnyObject, def: ObjectDef): void {
     }
   });
 
+  // a pending onDebounce call doesn't fire after its listener is gone
+  forEach(retained, ({ events, retain }) => {
+    forEach(events, (event) => {
+      if (retain.indexOf(event) === -1) {
+        const { domEvent, delegatedData } = event.info;
+        cancelIfGone(allEvents, domEvent ? domEvent.callback : delegatedData ? delegatedData.callback : event.callback);
+      }
+    });
+  });
+
   forEach(undelegations, ({ targets, delegatedData }) => {
     const { path, name, callback, context, info } = delegatedData;
     forEach(targets, (target) => {
diff --git a/src/on/_adddomlistener.ts b/src/on/_adddomlistener.ts
index 937120ee..c6104a5b 100644
--- a/src/on/_adddomlistener.ts
+++ b/src/on/_adddomlistener.ts
@@ -7,6 +7,7 @@ import createDomEventHandler from './_createdomeventhandler.js';
 import forEach from '../_helpers/foreach.js';
 import findDomListeners from './_finddomlisteners.js';
 import assign from '../_helpers/assign.js';
+import { addOwner } from './_owners.js';
 
 // _bind:KEY and _unbind:KEY always carry the node
 type BindEvent = { node: Node };
@@ -48,7 +49,15 @@ export default function addDomListener(
   const bindEventName = `_bind:${key}`;
   const domEventData = { eventName, selector, callback, context };
 
-  if (findDomListeners(def.events[bindEventName], domEventData, true).length) {
+  const [existing] = findDomListeners(def.events[bindEventName], domEventData, true);
+
+  if (existing) {
+    // the listener is kept until everyone who added it removes it
+    const { domEvent } = existing.info;
+    forEach(def.events[`_unbind:${key}`], (event) => {
+      if (event.info.domEvent === domEvent) addOwner(event, info.owner ?? null);
+    });
+    addOwner(existing, info.owner ?? null);
     return false;
   }
 
diff --git a/src/once.ts b/src/once.ts
index 4064cf30..223e5007 100644
--- a/src/once.ts
+++ b/src/once.ts
@@ -31,7 +31,11 @@ export default function once(this: any, object: any, names: any, givenCallback?:
     return object;
   }
 
+  let called = false;
   const callback = function onceCallback(this: any) {
+    // a trigger that started before the listener was removed still reaches it
+    if (called) return;
+    called = true;
     // remove event listener before its call, so the handler can fire its own event again
     off(object, names, onceCallback, context);
     apply(givenCallback, this, arguments);
diff --git a/test/spec/regressions/sweep5_events_spec.js b/test/spec/regressions/sweep5_events_spec.js
new file mode 100644
index 00000000..e2042149
--- /dev/null
+++ b/test/spec/regressions/sweep5_events_spec.js
@@ -0,0 +1,203 @@
+import MatreshkaArray from 'src/array';
+import on from 'src/on';
+import off from 'src/off';
+import once from 'src/once';
+import onDebounce from 'src/ondebounce';
+import trigger from 'src/trigger';
+import bindNode from 'src/bindnode';
+import defs from 'src/_core/defs';
+
+const wait = (ms = 30) => new Promise((resolve) => setTimeout(resolve, ms));
+const click = (node) => node.dispatchEvent(new window.MouseEvent('click', { bubbles: true, cancelable: true }));
+const makeNode = () => window.document.body.appendChild(window.document.createElement('div'));
+
+describe('sweep 5 (events)', () => {
+  it('EV-1a off of one delegated path keeps the DOM listener another path to the same object holds', () => {
+    const shared = {};
+    const obj = { a: shared, b: shared };
+    const node = makeNode();
+    bindNode(shared, 'x', node);
+    const f = vi.fn();
+    on(obj, 'a@click::x', f);
+    on(obj, 'b@click::x', f);
+    off(obj, 'a@click::x', f);
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+    off(obj, 'b@click::x', f);
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it('EV-1b replacing one branch keeps the DOM listener the other path holds', () => {
+    const shared = {};
+    const obj = { a: shared, b: shared };
+    const node = makeNode();
+    bindNode(shared, 'x', node);
+    const f = vi.fn();
+    on(obj, 'a@click::x', f);
+    on(obj, 'b@click::x', f);
+    obj.a = {};
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it("EV-1c a child's own DOM listener stays when a parent's identical delegation goes", () => {
+    const child = {};
+    const ctx = {};
+    const obj = { a: child };
+    const node = makeNode();
+    bindNode(child, 'x', node);
+    const f = vi.fn();
+    on(child, 'click::x', f, ctx);
+    on(obj, 'a@click::x', f, ctx);
+    off(obj, 'a@click::x', f);
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+    off(child, 'click::x', f);
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it("EV-1d off(child, 'click::x') keeps the parent's delegation, as off(child, 'x') does", () => {
+    const obj = { a: {} };
+    const f = vi.fn();
+    const node = makeNode();
+    bindNode(obj.a, 'x', node);
+    on(obj, 'a@click::x', f);
+    off(obj.a, 'click::x');
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it('EV-1e a delegated DOM listener next to another one on the same key keeps and drops only its own entries', () => {
+    const child = {};
+    const obj = { a: child };
+    const node = makeNode();
+    bindNode(child, 'x', node);
+    const ctx = {};
+    const f = vi.fn();
+    const g = vi.fn();
+    on(child, 'click::x', g);
+    on(child, 'click::x', f, ctx);
+    on(obj, 'a@click::x', f, ctx);
+    off(obj, 'a@click::x', f);
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+    off(child, 'click::x', f);
+    click(node);
+    expect(f).toHaveBeenCalledTimes(1);
+    expect(g).toHaveBeenCalledTimes(2);
+    expect(defs.get(child).events['_bind:x']).toHaveLength(1);
+    expect(defs.get(child).events['_unbind:x']).toHaveLength(1);
+  });
+
+  it('EV-2 on/off of a DOM event leaves no internal entries', () => {
+    const obj = {};
+    const f = () => {};
+    for (let i = 0; i < 3; i++) {
+      on(obj, 'click::x', f);
+      off(obj, 'click::x', f);
+    }
+    expect(defs.get(obj).events['_bind:x']).toBeUndefined();
+    expect(defs.get(obj).events['_unbind:x']).toBeUndefined();
+  });
+
+  it('EV-3a removing one array item keeps the pending debounced call from another item', async () => {
+    const arr = new MatreshkaArray({ x: 0 }, { x: 0 });
+    const f = vi.fn();
+    onDebounce(arr, '*@change:x', f, 5);
+    arr[0].x = 1;
+    arr.pop();
+    await wait();
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it('EV-3b replacing the branch right after a change keeps the pending debounced call', async () => {
+    const obj = { a: { x: 0 } };
+    const f = vi.fn();
+    onDebounce(obj, 'a@change:x', f, 5);
+    obj.a.x = 1;
+    obj.a = { x: 5 };
+    await wait();
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it("EV-3c the user's off of a delegated debounced listener still cancels its pending call", async () => {
+    const obj = { a: { x: 0 } };
+    const f = vi.fn();
+    onDebounce(obj, 'a@change:x', f, 5);
+    obj.a.x = 1;
+    off(obj, 'a@change:x', f);
+    await wait();
+    expect(f).not.toHaveBeenCalled();
+  });
+
+  it("EV-3d the user's off of one delegated name keeps the pending call of another name on the same debounce", async () => {
+    const obj = { a: { x: 0 }, b: { x: 0 } };
+    const f = vi.fn();
+    onDebounce(obj, 'a@change:x b@change:x', f, 5);
+    obj.b.x = 1;
+    off(obj, 'a@change:x', f);
+    await wait();
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it('EV-4a off(name, callback) cancels a pending DOM onDebounce call', async () => {
+    const obj = {};
+    const node = makeNode();
+    bindNode(obj, 'x', node);
+    const f = vi.fn();
+    onDebounce(obj, 'click::x', f, 5);
+    click(node);
+    off(obj, 'click::x', f);
+    await wait();
+    expect(f).not.toHaveBeenCalled();
+  });
+
+  it('EV-4b off() with no arguments cancels a pending DOM onDebounce call', async () => {
+    const obj = {};
+    const node = makeNode();
+    bindNode(obj, 'x', node);
+    const f = vi.fn();
+    onDebounce(obj, 'click::x', f, 5);
+    click(node);
+    off(obj);
+    await wait();
+    expect(f).not.toHaveBeenCalled();
+  });
+
+  it('EV-4c off of the DOM name keeps the pending call of a plain name on the same debounce', async () => {
+    const obj = {};
+    const node = makeNode();
+    bindNode(obj, 'x', node);
+    const f = vi.fn();
+    onDebounce(obj, 'click::x y', f, 5);
+    trigger(obj, 'y');
+    off(obj, 'click::x', f);
+    await wait();
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it('EV-5a once fires once when an earlier change handler changes the value again', () => {
+    const obj = { x: 0 };
+    const f = vi.fn();
+    on(obj, 'change:x', () => {
+      if (obj.x === 1) obj.x = 2;
+    });
+    once(obj, 'change:x', f);
+    obj.x = 1;
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it('EV-5b once fires once when an earlier handler triggers the event again', () => {
+    const obj = {};
+    const f = vi.fn();
+    let depth = 0;
+    on(obj, 'x', () => {
+      if (!depth++) trigger(obj, 'x');
+    });
+    once(obj, 'x', f);
+    trigger(obj, 'x');
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+});

From 8df23c324545787a0b6c412eb0d7ed245658411c Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:30:34 +0400
Subject: [PATCH 3/7] fix: sweep 5 array

---
 docs/content/en/api/matreshka-array/method.md |   2 +-
 docs/content/ru/api/matreshka-array/method.md |   2 +-
 docs/content/ua/api/matreshka-array/method.md |   2 +-
 .../_processrendering/checkbeforechange.ts    |  53 ++++++
 src/array/_processrendering/index.ts          |   4 -
 .../_processrendering/processspliceadd.ts     |   9 +-
 .../createaddingmethod.ts                     |   6 +-
 .../_pseudonativemethods/createcopywithin.ts  |   3 +
 src/array/_pseudonativemethods/createfill.ts  |   3 +
 .../createpseudonativemethod.ts               |  31 +++-
 .../_pseudonativemethods/createsplice.ts      |  11 +-
 src/array/restore.ts                          |  24 ++-
 test/spec/matreshka_array/renderer_spec.js    |   3 +-
 test/spec/regressions/sweep5_array_spec.js    | 153 ++++++++++++++++++
 14 files changed, 291 insertions(+), 15 deletions(-)
 create mode 100644 src/array/_processrendering/checkbeforechange.ts
 create mode 100644 test/spec/regressions/sweep5_array_spec.js

diff --git a/docs/content/en/api/matreshka-array/method.md b/docs/content/en/api/matreshka-array/method.md
index f91b7dd8..9c742a10 100644
--- a/docs/content/en/api/matreshka-array/method.md
+++ b/docs/content/en/api/matreshka-array/method.md
@@ -49,7 +49,7 @@ Yet they work the same as the ``Array.prototype``. There are only a few remarks:
 - The methods which should return a new array (``splice``, ``slice``, ``filter``, ``map``...) return a new ``Matreshka.Array`` instance.
 - The ``keys``, ``values`` and ``entries`` methods return an array instead of an iterator.
 - ``fill`` reports the replaced items as ``removed`` in the ``remove`` and ``modify`` events, and ``added`` holds one item per filled index.
-- ``fill`` and ``copyWithin`` throw an error on a rendered array (one that has a ``container`` or a ``sandbox``).
+- ``fill`` and ``copyWithin`` throw an error on a rendered array (one that has a ``container`` or a ``sandbox``) and leave it unchanged.
 
 Moreover, the methods generate events which are fired on any array modification. For more detailed information look at [`Matreshka.Array`](/api/matreshka-array/).
 
diff --git a/docs/content/ru/api/matreshka-array/method.md b/docs/content/ru/api/matreshka-array/method.md
index e1f6b24a..f9f61306 100644
--- a/docs/content/ru/api/matreshka-array/method.md
+++ b/docs/content/ru/api/matreshka-array/method.md
@@ -49,7 +49,7 @@ Matreshka.Array#METHOD()
 - Методы, которые в оригинальном виде возвращают новый массив (``splice``, ``slice``, ``filter``, ``map``...), возвращают новый экземпляр ``Matreshka.Array``.
 - Методы ``keys``, ``values`` и ``entries`` возвращают массив вместо итератора.
 - ``fill`` передаёт заменённые элементы как ``removed`` в события ``remove`` и ``modify``, а ``added`` содержит по одному элементу на каждый заполненный индекс.
-- ``fill`` и ``copyWithin`` бросают ошибку на отрендеренном массиве (у которого есть ``container`` или ``sandbox``).
+- ``fill`` и ``copyWithin`` бросают ошибку на отрендеренном массиве (у которого есть ``container`` или ``sandbox``) и не меняют его.
 
 Кроме всего, методы генерируют события связанные с любой модификацией массива. Подробнее см. [`Matreshka.Array`](/ru/api/matreshka-array/).
 
diff --git a/docs/content/ua/api/matreshka-array/method.md b/docs/content/ua/api/matreshka-array/method.md
index 1ffd6cb6..64c49995 100644
--- a/docs/content/ua/api/matreshka-array/method.md
+++ b/docs/content/ua/api/matreshka-array/method.md
@@ -49,7 +49,7 @@ Matreshka.Array#METHOD()
 - Методи, які в оригінальному вигляді повертають новий масив (``splice``, ``slice``, ``filter``, ``map`` ...), повертають новий екземпляр ``Matreshka.Array``.
 - Методи ``keys``, ``values`` та ``entries`` повертають масив замість ітератора.
 - ``fill`` передає замінені елементи як ``removed`` у події ``remove`` і ``modify``, а ``added`` містить по одному елементу на кожен заповнений індекс.
-- ``fill`` і ``copyWithin`` кидають помилку на відрендереному масиві (у якого є ``container`` або ``sandbox``).
+- ``fill`` і ``copyWithin`` кидають помилку на відрендереному масиві (у якого є ``container`` або ``sandbox``) і не змінюють його.
 
 Крім усього, методи генерують події пов'язані з будь-якою модифікацією масиву. Детальніше див. [`Matreshka.Array`](/ua/api/matreshka-array/).
 
diff --git a/src/array/_processrendering/checkbeforechange.ts b/src/array/_processrendering/checkbeforechange.ts
new file mode 100644
index 00000000..d060a9f9
--- /dev/null
+++ b/src/array/_processrendering/checkbeforechange.ts
@@ -0,0 +1,53 @@
+import matreshkaError from '../../_helpers/matreshkaerror.js';
+import forEach from '../../_helpers/foreach.js';
+import checkAlreadyRendered from './checkalreadyrendered.js';
+import type { ArrayDef, ArrayMethodOptions, MatreshkaArrayInstance } from '../types.js';
+
+// whether a change made with these options renders: rendering is on and the array has a container
+export function rendersChange(self: MatreshkaArrayInstance, eventOptions?: ArrayMethodOptions | null): boolean {
+  const { renderIfPossible = true } = self;
+  return !!(renderIfPossible && !eventOptions?.dontRender && (self.nodes.container || self.nodes.sandbox));
+}
+
+// fill and copyWithin can't render: they throw before they change the array
+export function checkCompatRenderer(
+  self: MatreshkaArrayInstance,
+  method: string,
+  eventOptions?: ArrayMethodOptions | null
+): void {
+  if (rendersChange(self, eventOptions)) {
+    throw matreshkaError('array:method_compat_renderer', { method });
+  }
+}
+
+// an adding method throws before it changes the array where rendering the added items would throw: an item
+// rendered already, or one object twice; an item the same splice removes (`kept`) keeps its node, which moves
+export default function checkAddedItems(
+  self: MatreshkaArrayInstance,
+  selfDef: ArrayDef,
+  added: any[],
+  eventOptions?: ArrayMethodOptions | null,
+  kept?: any[]
+): void {
+  if (!rendersChange(self, eventOptions)) {
+    return;
+  }
+
+  const rendering = new WeakMap<object, true>();
+  const { itemRenderer } = self as MatreshkaArrayInstance & { itemRenderer?: unknown };
+
+  forEach(added, (item) => {
+    if (item && typeof item === 'object' && !(kept && kept.indexOf(item) !== -1)) {
+      checkAlreadyRendered({ item, selfDef });
+
+      // only an item with a renderer gets a node, so only its second place throws
+      if (item.renderer || itemRenderer) {
+        if (rendering.has(item)) {
+          throw matreshkaError('array:add_render_twice');
+        }
+
+        rendering.set(item, true);
+      }
+    }
+  });
+}
diff --git a/src/array/_processrendering/index.ts b/src/array/_processrendering/index.ts
index 95ba8f83..36b50d9c 100644
--- a/src/array/_processrendering/index.ts
+++ b/src/array/_processrendering/index.ts
@@ -1,5 +1,4 @@
 import defs from '../../_core/defs.js';
-import matreshkaError from '../../_helpers/matreshkaerror.js';
 import processPush from './processpush.js';
 import processUnshift from './processunshift.js';
 import processRecreate from './processrecreate.js';
@@ -36,9 +35,6 @@ export default function processRendering({
   addContainer(selfDef, container);
 
   switch (method) {
-    case 'fill':
-    case 'copyWithin':
-      throw matreshkaError('array:method_compat_renderer', { method });
     case 'push':
       processPush({
         self,
diff --git a/src/array/_processrendering/processspliceadd.ts b/src/array/_processrendering/processspliceadd.ts
index 52ad541b..97bb29c9 100644
--- a/src/array/_processrendering/processspliceadd.ts
+++ b/src/array/_processrendering/processspliceadd.ts
@@ -14,15 +14,20 @@ export default function processSpliceAdd({ self, selfDef, eventOptions, containe
   const { added, silent } = eventOptions;
   let nextNode: ChildNode | undefined;
 
-  // find the first rendered node after the last added item to insert newly rendered items before it
+  // find the first rendered node after the last added item to insert newly rendered items before it;
+  // a node out of the container (the container was rebound) doesn't count
   for (let i = (eventOptions[spliceStart] as number) + added.length; i < self.length && !nextNode; i++) {
     const next = self[i];
 
     if (next && typeof next === 'object') {
-      nextNode = getAlreadyRendered({
+      const node = getAlreadyRendered({
         item: next,
         selfDef
       });
+
+      if (node && node.parentNode === container) {
+        nextNode = node;
+      }
     }
   }
 
diff --git a/src/array/_pseudonativemethods/createaddingmethod.ts b/src/array/_pseudonativemethods/createaddingmethod.ts
index d5b46aa7..9761fa5b 100644
--- a/src/array/_pseudonativemethods/createaddingmethod.ts
+++ b/src/array/_pseudonativemethods/createaddingmethod.ts
@@ -2,6 +2,7 @@ import syncFields from '../_syncfields.js';
 import reportModified from '../_reportmodified.js';
 import assign from '../../_helpers/assign.js';
 import withLengthOptions from '../_withlengthoptions.js';
+import checkAddedItems from '../_processrendering/checkbeforechange.js';
 import type { ArrayDef, ArrayEventOptions, MatreshkaArrayInstance } from '../types.js';
 
 // creates methods: push, unshift, push_, unshift_
@@ -10,7 +11,8 @@ export default function createAddingMethod(
   hasOptions: boolean
 ): (this: MatreshkaArrayInstance, ...args: any[]) => number {
   return function pseudoNativeMethod(this: MatreshkaArrayInstance): number {
-    const { itemMediator }: ArrayDef = syncFields(this);
+    const selfDef: ArrayDef = syncFields(this);
+    const { itemMediator } = selfDef;
     // +hasOptions is converted to 0 or 1 depending on its value (false/true)
     const argsLength = Math.max(arguments.length - +hasOptions, 0);
     const args: any[] = Array(argsLength);
@@ -35,6 +37,8 @@ export default function createAddingMethod(
       }
     }
 
+    checkAddedItems(this, selfDef, args, givenEventOptions);
+
     if (isPush) {
       // insert new items to the end of array
       for (let i = 0; i < argsLength; i++) {
diff --git a/src/array/_pseudonativemethods/createcopywithin.ts b/src/array/_pseudonativemethods/createcopywithin.ts
index 14bdf512..57810582 100644
--- a/src/array/_pseudonativemethods/createcopywithin.ts
+++ b/src/array/_pseudonativemethods/createcopywithin.ts
@@ -3,6 +3,7 @@ import apply from '../../_helpers/apply.js';
 import reportModified from '../_reportmodified.js';
 import assign from '../../_helpers/assign.js';
 import itemsNotIn from '../_diffitems.js';
+import { checkCompatRenderer } from '../_processrendering/checkbeforechange.js';
 import type { ArrayEventOptions, MatreshkaArrayInstance } from '../types.js';
 import toArray from '../../_helpers/toarray.js';
 
@@ -20,6 +21,8 @@ export default function createCopyWithin(
       args[i] = arguments[i];
     }
 
+    checkCompatRenderer(this, 'copyWithin', givenEventOptions);
+
     const was = toArray(this);
     apply(Array.prototype.copyWithin, this, args);
 
diff --git a/src/array/_pseudonativemethods/createfill.ts b/src/array/_pseudonativemethods/createfill.ts
index 89f29ea9..f3581d76 100644
--- a/src/array/_pseudonativemethods/createfill.ts
+++ b/src/array/_pseudonativemethods/createfill.ts
@@ -2,6 +2,7 @@ import syncFields from '../_syncfields.js';
 import reportModified from '../_reportmodified.js';
 import assign from '../../_helpers/assign.js';
 import toAbsoluteIndex from '../_toabsoluteindex.js';
+import { checkCompatRenderer } from '../_processrendering/checkbeforechange.js';
 import type { ArrayDef, ArrayEventOptions, MatreshkaArrayInstance } from '../types.js';
 
 export default function createFill(
@@ -23,6 +24,8 @@ export default function createFill(
       return this;
     }
 
+    checkCompatRenderer(this, 'fill', givenEventOptions);
+
     for (let i = from; i < to; i++) {
       const item = useMediator ? itemMediator(value, i) : value;
 
diff --git a/src/array/_pseudonativemethods/createpseudonativemethod.ts b/src/array/_pseudonativemethods/createpseudonativemethod.ts
index cb60d980..6b3b283c 100644
--- a/src/array/_pseudonativemethods/createpseudonativemethod.ts
+++ b/src/array/_pseudonativemethods/createpseudonativemethod.ts
@@ -24,7 +24,7 @@ export const changingMethodNames = [
 ] as const;
 
 // the methods that copy; they return a Matreshka.Array
-const copyingMethodNames = ['map', 'filter', 'slice', 'flat', 'flatMap', 'toSorted', 'toReversed', 'toSpliced', 'with'];
+const copyingMethodNames = ['map', 'filter', 'slice', 'toSorted', 'toReversed', 'toSpliced', 'with'];
 
 export const methodNames = [
   ...changingMethodNames,
@@ -61,6 +61,31 @@ const arrayPrototype = Array.prototype as unknown as Record<
   (this: MatreshkaArrayInstance, ...args: any[]) => any
 >;
 
+// a nested Matreshka.Array is spread like an array, as concat does: up to `depth` levels are made arrays
+function spreadNested(value: any, depth: number): any {
+  return depth >= 1 && value && typeof value === 'object' && (value.isMatreshkaArray || Array.isArray(value))
+    ? arrayPrototype.map.call(value, (item: any) => spreadNested(item, depth - 1))
+    : value;
+}
+
+function flat(this: MatreshkaArrayInstance, depth?: any): MatreshkaArrayInstance {
+  const levels = typeof depth === 'undefined' ? 1 : +depth || 0;
+  const items = arrayPrototype.map.call(this, (item: any) => spreadNested(item, levels));
+  return toMatreshkaArray(apply(arrayPrototype.flat, items, arguments));
+}
+
+function flatMap(this: MatreshkaArrayInstance, callback: any, thisArg?: any): MatreshkaArrayInstance {
+  // a non-function goes as is, so the native method throws its TypeError
+  const spreading =
+    typeof callback === 'function'
+      ? function spreadResult(this: any) {
+          const result = apply(callback, this, arguments);
+          return result && typeof result === 'object' && result.isMatreshkaArray ? result.toJSON(false) : result;
+        }
+      : callback;
+  return toMatreshkaArray(arrayPrototype.flatMap.call(this, spreading, thisArg));
+}
+
 // creates pseudo native method and returns it (push, push_, sort, sort_...)
 export default function createPseudoNativeMethod(
   name: (typeof methodNames)[number],
@@ -82,6 +107,10 @@ export default function createPseudoNativeMethod(
       return createCopyWithin(hasOptions);
     case 'fill':
       return createFill(hasOptions);
+    case 'flat':
+      return flat;
+    case 'flatMap':
+      return flatMap;
     case 'forEach':
       return function pseudoNativeMethod(this: MatreshkaArrayInstance) {
         apply(arrayPrototype.forEach, this, arguments);
diff --git a/src/array/_pseudonativemethods/createsplice.ts b/src/array/_pseudonativemethods/createsplice.ts
index ce142dfb..6e6e21f2 100644
--- a/src/array/_pseudonativemethods/createsplice.ts
+++ b/src/array/_pseudonativemethods/createsplice.ts
@@ -6,15 +6,19 @@ import assign from '../../_helpers/assign.js';
 import withLengthOptions from '../_withlengthoptions.js';
 import toAbsoluteIndex from '../_toabsoluteindex.js';
 import { spliceStart } from '../_processrendering/processspliceadd.js';
+import checkAddedItems from '../_processrendering/checkbeforechange.js';
 import type { ArrayDef, ArrayEventOptions, MatreshkaArrayInstance } from '../types.js';
 
+const { slice } = Array.prototype;
+
 // creates splice or splice_ method and returns it
 // TODO: Improve readability of createSplice function
 export default function createSplice(
   hasOptions: boolean
 ): (this: MatreshkaArrayInstance, ...args: any[]) => MatreshkaArrayInstance {
   return function pseudoNativeMethod(this: MatreshkaArrayInstance): MatreshkaArrayInstance {
-    const { itemMediator }: ArrayDef = syncFields(this);
+    const selfDef: ArrayDef = syncFields(this);
+    const { itemMediator } = selfDef;
     const functionArguments = arguments;
     const argsLength = Math.max(functionArguments.length - +hasOptions, 0);
     const args: any[] = Array(argsLength);
@@ -36,6 +40,11 @@ export default function createSplice(
       }
     }
 
+    if (added.length) {
+      // the items this splice removes keep their nodes
+      checkAddedItems(this, selfDef, added, givenEventOptions, slice.call(this, start, start + +args[1]));
+    }
+
     // call original method
     // TODO: Change array manually in splice method for better performance
     const returns: any[] = withLengthOptions(this, givenEventOptions, () => apply(Array.prototype.splice, this, args));
diff --git a/src/array/restore.ts b/src/array/restore.ts
index 4fe3d54e..9ef9d8aa 100644
--- a/src/array/restore.ts
+++ b/src/array/restore.ts
@@ -7,9 +7,29 @@ import getNodes from '../bindnode/_getnodes.js';
 import renderedNodes from './_processrendering/renderednodes.js';
 import syncFields from './_syncfields.js';
 import { addContainer } from './_processrendering/index.js';
-import type { ArrayDef, ArrayMethodOptions, ItemEventOptions, MatreshkaArrayInstance, RenderedNode } from './types.js';
+import modelCall from './_modelcall.js';
+import type {
+  ArrayDef,
+  ArrayMethodOptions,
+  ItemEventOptions,
+  MatreshkaArrayInstance,
+  ModelConstructor,
+  RenderedNode
+} from './types.js';
 import assign from '../_helpers/assign.js';
 
+// a restored item has no data: a Model made of Matreshka.Array takes it as its items, as in the item mediator
+function createModel(Model: ModelConstructor, parentArray: MatreshkaArrayInstance, index: number): any {
+  const data = Model.prototype?.isMatreshkaArray ? [] : {};
+  modelCall.args = [data, parentArray, index];
+
+  try {
+    return new Model(data, parentArray, index);
+  } finally {
+    modelCall.args = null;
+  }
+}
+
 // restores Matreshka.Array from external nodes
 export default function restore(
   this: MatreshkaArrayInstance,
@@ -39,7 +59,7 @@ export default function restore(
   }
 
   forEach(nodes, (node, index) => {
-    const created = Model ? new Model({}, this, index) : {}; // create new item
+    const created = Model ? createModel(Model, this, index) : {}; // create new item
     // the item the array will hold: the mediated one is linked to the node
     const item = itemMediator ? itemMediator(created, index) : created;
     const { bindRenderedAsSandbox } = item;
diff --git a/test/spec/matreshka_array/renderer_spec.js b/test/spec/matreshka_array/renderer_spec.js
index 1d379673..c9b6a441 100644
--- a/test/spec/matreshka_array/renderer_spec.js
+++ b/test/spec/matreshka_array/renderer_spec.js
@@ -71,7 +71,8 @@ describe('Matreshka.Array renderer', () => {
 
     expect(() => arr.push(arr[0])).toThrow();
 
-    expect(arr.length).toEqual(n + 1);
+    // the array is left as it was
+    expect(arr.length).toEqual(n);
     expect(arr.itemRenderer).toHaveBeenCalledTimes(n);
     expect(arr.nodes.sandbox.children.length).toEqual(n);
   });
diff --git a/test/spec/regressions/sweep5_array_spec.js b/test/spec/regressions/sweep5_array_spec.js
new file mode 100644
index 00000000..5e454477
--- /dev/null
+++ b/test/spec/regressions/sweep5_array_spec.js
@@ -0,0 +1,153 @@
+// Regressions found by sweep 5, area: Matreshka.Array (AR-n in its report).
+// Every test here fails on fec0a1c.
+import MatreshkaArray from 'src/array';
+import Class from 'src/class';
+import MatreshkaObject from 'src/object';
+
+function renderedArray() {
+  const arr = new MatreshkaArray();
+  arr.bindNode('sandbox', '<ul></ul>');
+  arr.itemRenderer = '<li></li>';
+  return arr;
+}
+
+function reboundArray() {
+  const arr = new MatreshkaArray();
+  arr.bindNode('container', '<ul></ul>');
+  arr.itemRenderer = '<li></li>';
+  arr.push(new MatreshkaObject(), new MatreshkaObject());
+  arr.unbindNode('container');
+  arr.bindNode('container', '<ol></ol>');
+  return arr;
+}
+
+describe('sweep 5: Matreshka.Array', () => {
+  it('AR-1 splice after the container is rebound puts the new node into the current container', () => {
+    const arr = reboundArray();
+    expect(() => arr.splice(0, 0, new MatreshkaObject())).not.toThrow();
+    expect(arr.length).toBe(3);
+    expect([...arr.nodes.container.children]).toEqual([arr[0].nodes.sandbox]);
+  });
+
+  it('AR-1 splice after the container is rebound moves a kept item into the current container', () => {
+    const arr = reboundArray();
+    const first = arr[0];
+
+    expect(() => arr.splice(0, 1, first)).not.toThrow();
+    expect([...arr.nodes.container.children]).toEqual([first.nodes.sandbox]);
+  });
+
+  it('AR-2 restore with a Model made of Matreshka.Array gives every item an empty collection', () => {
+    const Inner = Class({ extends: MatreshkaArray });
+    const arr = new MatreshkaArray();
+    arr.Model = Inner;
+    arr.bindNode('sandbox', '<ul><li></li><li></li></ul>');
+    arr.restore();
+
+    expect(arr.length).toBe(2);
+    expect(arr[0]).toBeInstanceOf(Inner);
+    expect(arr.toJSON()).toEqual([[], []]);
+  });
+
+  it('AR-3 push and unshift of an item rendered already throw and leave the array as it was', () => {
+    const arr = renderedArray();
+    const x = {};
+    arr.push(x);
+    const modify = vi.fn();
+    arr.on('modify', modify);
+
+    expect(() => arr.push({}, x)).toThrow(/inserted twice/);
+    expect(() => arr.unshift({}, x)).toThrow(/inserted twice/);
+    expect(arr.length).toBe(1);
+    expect(arr.nodes.sandbox.children.length).toBe(1);
+    expect(modify).not.toHaveBeenCalled();
+    // where nothing renders, the item may be added again
+    arr.push_(x, { dontRender: true });
+    arr.renderIfPossible = false;
+    arr.unshift(x);
+    expect(arr.length).toBe(3);
+    const unbound = new MatreshkaArray();
+    unbound.itemRenderer = '<li></li>';
+    unbound.push(x, x);
+    expect(unbound.length).toBe(2);
+  });
+
+  it('AR-3 the same new item twice in one call throws before the array changes', () => {
+    const arr = renderedArray();
+    const x = {};
+
+    expect(() => arr.push(x, x)).toThrow(/inserted twice/);
+    expect(arr.length).toBe(0);
+    expect(arr.nodes.sandbox.children.length).toBe(0);
+    // with no renderer nothing renders, so nothing throws
+    const plain = new MatreshkaArray();
+    plain.bindNode('sandbox', '<ul></ul>');
+    plain.push(x, x);
+    expect(plain.length).toBe(2);
+  });
+
+  it('AR-3 splice adding an item rendered elsewhere in the array throws and changes nothing', () => {
+    const arr = renderedArray();
+    const a = new MatreshkaObject();
+    const b = new MatreshkaObject();
+    arr.push(a, b);
+
+    expect(() => arr.splice(0, 1, b)).toThrow(/inserted twice/);
+    expect(() => arr.splice(0, 0, {}, a)).toThrow(/inserted twice/);
+    expect(arr[0] === a && arr[1] === b && arr.length === 2).toBe(true);
+    // an item the same splice removes is kept and moves
+    arr.splice(0, 2, b, a);
+    expect([...arr.nodes.sandbox.children]).toEqual([b.nodes.sandbox, a.nodes.sandbox]);
+    arr.splice(1, Number.NaN, {});
+    arr.splice(0, -1, {});
+    expect(arr.length).toBe(4);
+  });
+
+  it('AR-3 fill and copyWithin on a rendered array throw before they change it', () => {
+    const arr = renderedArray();
+    const a = {};
+    const b = {};
+    arr.push(a, b);
+
+    expect(() => arr.fill(a)).toThrow(/fill/);
+    expect(() => arr.copyWithin(0, 1)).toThrow(/copyWithin/);
+    expect(arr[0] === a && arr[1] === b).toBe(true);
+    // an empty range changes nothing and throws nothing, as before
+    expect(arr.fill(a, 2)).toBe(arr);
+    arr.fill_(a, { dontRender: true });
+    arr.copyWithin_(0, 1, { dontRender: true });
+    expect(arr[1] === a).toBe(true);
+  });
+
+  it('AR-4 flat spreads a nested Matreshka.Array at every level, as it does an array', () => {
+    const arr = MatreshkaArray.of(MatreshkaArray.of(1, 2), 3, [MatreshkaArray.of(4)]);
+
+    expect(arr.flat()).toBeInstanceOf(MatreshkaArray);
+    expect(arr.flat().toJSON(false)).toEqual([1, 2, 3, arr[2][0]]);
+    expect(arr.flat(2).toJSON()).toEqual([1, 2, 3, 4]);
+    expect(arr.flat(Number.POSITIVE_INFINITY).toJSON()).toEqual([1, 2, 3, 4]);
+    expect(arr.flat(0).toJSON(false)).toEqual([arr[0], 3, arr[2]]);
+    expect(MatreshkaArray.of(MatreshkaArray.of(MatreshkaArray.of(5))).flat(1.5)[0]).toBeInstanceOf(MatreshkaArray);
+    // a hole is skipped, as by the native method
+    const holes = new MatreshkaArray(2);
+    holes[1] = MatreshkaArray.of(6);
+    expect(holes.flat().toJSON()).toEqual([6]);
+  });
+
+  it('AR-4 flatMap spreads a Matreshka.Array returned by the callback', () => {
+    const arr = MatreshkaArray.of(1, 2);
+    const context = {};
+    const calls = [];
+    const result = arr.flatMap(function callback(x, index, self) {
+      calls.push([this, index, self]);
+      return x === 1 ? MatreshkaArray.of(x, x) : [x];
+    }, context);
+
+    expect(result.toJSON()).toEqual([1, 1, 2]);
+    expect(calls).toEqual([
+      [context, 0, arr],
+      [context, 1, arr]
+    ]);
+    expect(() => new MatreshkaArray().flatMap(null)).toThrow(TypeError);
+  });
+});

From 1dee3c277b121224fd777ce77e166e9cfecd47a7 Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:30:59 +0400
Subject: [PATCH 4/7] fix: sweep 5 router

---
 docs/content/en/api/router.md               |   2 +-
 docs/content/ru/api/router.md               |   2 +-
 docs/content/ua/api/router.md               |   2 +-
 src/router/router.ts                        |  99 ++++++++++---
 test/spec/regressions/sweep5_router_spec.js | 156 ++++++++++++++++++++
 5 files changed, 237 insertions(+), 24 deletions(-)
 create mode 100644 test/spec/regressions/sweep5_router_spec.js

diff --git a/docs/content/en/api/router.md b/docs/content/en/api/router.md
index adb4e404..e4a933cf 100644
--- a/docs/content/en/api/router.md
+++ b/docs/content/en/api/router.md
@@ -41,7 +41,7 @@ By changing these properties you can trigger needed procedures (update the path,
 #### Methods
 
 - ``subscribe(object, route)`` - subscribes object for route changes.
-- ``init()`` - used for lazy initialization in  ``subscribe`` method (no need to call it manually).
+- ``init()`` - used for lazy initialization on first use of ``Matreshka.Router.hash`` or ``Matreshka.Router.history`` and in the ``subscribe`` method (no need to call it manually).
 
 ## Arguments
 
diff --git a/docs/content/ru/api/router.md b/docs/content/ru/api/router.md
index 5cac2fe3..a7836c3f 100644
--- a/docs/content/ru/api/router.md
+++ b/docs/content/ru/api/router.md
@@ -41,7 +41,7 @@ Matreshka.Router.hash.path = '/foo/bar/baz/';
 #### Методы
 
 - ``subscribe(object, route)`` - подписывает объект на изменения маршрута.
-- ``init()`` - используется для ленивой инициализации в методе ``subscribe`` (вызывать вручную не нужно).
+- ``init()`` - используется для ленивой инициализации при первом обращении к ``Matreshka.Router.hash`` или ``Matreshka.Router.history`` и в методе ``subscribe`` (вызывать вручную не нужно).
 
 ## Аргументы
 
diff --git a/docs/content/ua/api/router.md b/docs/content/ua/api/router.md
index cb9bda72..3d89bbb7 100644
--- a/docs/content/ua/api/router.md
+++ b/docs/content/ua/api/router.md
@@ -41,7 +41,7 @@ Matreshka.Router.hash.path = '/foo/bar/baz/';
 #### Методи
 
 - ``subscribe(object, route)`` - підписує об'єкт на зміни маршруту.
-- ``init()`` - використовується для лінивої ініціалізації в методі ``subscribe`` (викликати вручну не потрібно).
+- ``init()`` - використовується для лінивої ініціалізації при першому зверненні до ``Matreshka.Router.hash`` або ``Matreshka.Router.history`` і в методі ``subscribe`` (викликати вручну не потрібно).
 
 ## Аргументи
 
diff --git a/src/router/router.ts b/src/router/router.ts
index 25eff781..30530cdc 100644
--- a/src/router/router.ts
+++ b/src/router/router.ts
@@ -33,6 +33,27 @@ function splitPath(path: string): string[] {
   return trimmed ? trimmed.split('/') : [];
 }
 
+// the parts up to the first empty one, as a path: ['a', 'b'] → '/a/b/'
+function toPath(parts: string[]): string {
+  const nonEmptyParts: string[] = [];
+
+  for (let i = 0; i < parts.length; i++) {
+    if (isPart(parts[i])) {
+      nonEmptyParts.push(encodeURIComponent(parts[i]));
+    } else {
+      break;
+    }
+  }
+
+  return nonEmptyParts.length ? `/${nonEmptyParts.join('/')}/` : '/';
+}
+
+// the same route in any spelling: '/a' and '/a/', '%40' and '@'
+const route = (path: string) => splitPath(path).map(decode).join('/');
+
+// the hash and history singletons, made and initialized on first use
+const singletons: { hash?: Router; history?: Router } = {};
+
 function handlePopStateChange(router: Router): void {
   set(router, 'path', window.location.pathname, {
     popEvent: true
@@ -40,7 +61,7 @@ function handlePopStateChange(router: Router): void {
 }
 
 class Router {
-  // the singletons, set below
+  // the singletons, defined below
   declare static history: Router;
   declare static hash: Router;
 
@@ -57,13 +78,20 @@ class Router {
 
   constructor(type: RouterType | (string & {})) {
     // the history and hash routers are singletons
-    const singleton = type === 'hash' ? Router.hash : type === 'history' ? Router.history : undefined;
+    const kind = type === 'hash' || type === 'history' ? (type as RouterType) : undefined;
+    const singleton = kind && singletons[kind];
     if (singleton) {
       // biome-ignore lint/correctness/noConstructorReturn: new Router('hash') gives Router.hash
       return singleton;
     }
 
     this.type = type;
+
+    if (kind) {
+      singletons[kind] = this;
+      // a singleton reads the URL as soon as it exists, so it can be bound like any object
+      this.init();
+    }
   }
 
   init(): this {
@@ -84,19 +112,7 @@ class Router {
         },
         path: {
           source: 'parts',
-          handler(parts: string[]) {
-            const nonEmptyParts: string[] = [];
-
-            for (let i = 0; i < parts.length; i++) {
-              if (isPart(parts[i])) {
-                nonEmptyParts.push(encodeURIComponent(parts[i]));
-              } else {
-                break;
-              }
-            }
-
-            return nonEmptyParts.length ? `/${nonEmptyParts.join('/')}/` : '/';
-          }
+          handler: toPath
         }
       },
       { debounceCalc: false }
@@ -148,7 +164,6 @@ class Router {
 
         window.addEventListener('hashchange', () => handleHashChange(this));
 
-        const route = (path: string) => splitPath(path).map(decode).join('/');
         onDebounce(this, 'change:hashPath', (evt) => {
           const isRoute = location.hash.slice(0, 2) === '#!';
           // an empty route leaves a plain anchor such as #top alone
@@ -158,8 +173,11 @@ class Router {
           // the same route in another spelling (#!/foo for #!/foo/, %40 for @) is rewritten in place, with no history entry
           if (isRoute && route(location.hash.slice(2)) === route(this.path)) {
             history.replaceState(history.state, '', this.hashPath || `${location.pathname}${location.search}`);
-          } else {
+          } else if (this.hashPath) {
             location.hash = this.hashPath;
+          } else {
+            // location.hash = '' would leave a bare '#'; pushState fires no hashchange, and the router already holds the new route
+            history.pushState(history.state, '', `${location.pathname}${location.search}`);
           }
         });
       } else if (type === 'history') {
@@ -177,10 +195,19 @@ class Router {
         });
 
         onDebounce(this, 'change:path', (evt) => {
-          if (!evt?.popEvent) {
+          if (evt?.popEvent) {
+            return;
+          }
+          // the route the URL already shows adds no entry; another spelling of it (/a for /a/) is rewritten in place
+          if (route(location.pathname) === route(this.path)) {
+            const canonical = toPath(splitPath(this.path).map(decode));
+            if (location.pathname !== canonical) {
+              history.replaceState(history.state, '', canonical + location.search + location.hash);
+            }
+          } else {
             history.pushState(null, '', this.path + location.search + location.hash);
-            ({ pathname } = location);
           }
+          ({ pathname } = location);
         });
       }
     }
@@ -198,6 +225,17 @@ class Router {
 
     this.init();
 
+    // the properties after an empty part get null: the URL can't show them
+    const resetAfter = (index: number) => {
+      for (let i = index + 1; i < keys.length; i++) {
+        if (keys[i] !== '*' && isPart(obj[keys[i]])) {
+          set(obj, keys[i], null, {
+            routeSilent: true
+          });
+        }
+      }
+    };
+
     for (let i = 0; i < filteredKeys.length; i++) {
       const key = filteredKeys[i];
       changeEvents.push(`change:${key}`);
@@ -220,6 +258,11 @@ class Router {
         }
       }
 
+      // a change:key triggered by hand has no event object
+      if (evt && !isPart(evt.value)) {
+        resetAfter(keys.indexOf(evt.key));
+      }
+
       this.parts = values;
     });
 
@@ -236,6 +279,8 @@ class Router {
     // the parts after this route stay in the URL
     if (parts.length === keys.length) {
       parts.push(...this.parts.slice(keys.length));
+    } else {
+      resetAfter(parts.length);
     }
 
     for (let i = 0; i < keys.length; i++) {
@@ -264,7 +309,19 @@ class Router {
   }
 }
 
-Router.history = new Router('history');
-Router.hash = new Router('hash');
+// a page that loads the library but never uses the router gets no listener
+for (const type of ['hash', 'history'] as const) {
+  Object.defineProperty(Router, type, {
+    configurable: true,
+    enumerable: true,
+    get: () => singletons[type] || new Router(type)
+  });
+}
+
+// dist/ assigns class methods (Babel's setClassMethods): as in a native class, a for-in doesn't list them
+const methods = Object.getOwnPropertyNames(Router.prototype);
+for (let i = 0; i < methods.length; i++) {
+  Object.defineProperty(Router.prototype, methods[i], { enumerable: false });
+}
 
 export default Router;
diff --git a/test/spec/regressions/sweep5_router_spec.js b/test/spec/regressions/sweep5_router_spec.js
new file mode 100644
index 00000000..91080832
--- /dev/null
+++ b/test/spec/regressions/sweep5_router_spec.js
@@ -0,0 +1,156 @@
+// Sweep 5: the router. Each test with an id fails on the code before the fix (ES5-7 on dist/: npm run test:dist);
+// the ids are the audit's.
+import { bindNode, binders, trigger } from 'src';
+
+const wait = (ms = 30) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// a new Router module per test, so the singletons start from the current URL
+async function freshRouter() {
+  vi.resetModules();
+  const { Router } = await import('src/router');
+  return Router;
+}
+
+const forInKeys = (object) => {
+  const keys = [];
+  for (const key in object) keys.push(key);
+  return keys;
+};
+
+describe('sweep 5: router', () => {
+  afterEach(() => {
+    history.replaceState(null, '', '/');
+  });
+
+  it('RT-1: a property changed and changed back before the write adds no history entry', async () => {
+    history.replaceState(null, '', '/start/');
+    const Router = await freshRouter();
+    const obj = {};
+    Router.history.subscribe(obj, '/a/');
+    await wait();
+    const { length } = history;
+
+    obj.a = 'x';
+    obj.a = 'start';
+    await wait();
+
+    expect(location.pathname).toBe('/start/');
+    expect(history.length).toBe(length);
+  });
+
+  it('RT-1: the path set in another spelling (/start for /start/) adds no history entry', async () => {
+    history.replaceState(null, '', '/start/');
+    const Router = await freshRouter();
+    Router.history.subscribe({}, '/a/');
+    await wait();
+    const { length } = history;
+
+    Router.history.path = '/start';
+    await wait();
+
+    expect(location.pathname).toBe('/start/');
+    expect(history.length).toBe(length);
+  });
+
+  it('RT-1: on a page opened at /start, the same route written back is rewritten to /start/ in place', async () => {
+    history.replaceState(null, '', '/start?q=1#top');
+    const Router = await freshRouter();
+    const obj = {};
+    Router.history.subscribe(obj, '/a/');
+    await wait();
+    expect(obj.a).toBe('start');
+    const { length } = history;
+
+    obj.a = 'x';
+    obj.a = 'start';
+    await wait();
+
+    expect(location.href).toBe('http://localhost/start/?q=1#top');
+    expect(history.length).toBe(length);
+  });
+
+  it('RT-2: a property that gets null makes the next ones null when the URL is already empty there', async () => {
+    const Router = await freshRouter();
+    const router = new Router('custom');
+    const obj = {};
+    router.subscribe(obj, '/a/b/');
+
+    obj.b = 'y'; // not shown: a is empty
+    expect(obj.b).toBe('y');
+    obj.a = null;
+
+    expect(router.path).toBe('/');
+    expect(obj.b).toBe(null);
+  });
+
+  it('a change event triggered by hand, with no event object, resets nothing', async () => {
+    const Router = await freshRouter();
+    const router = new Router('custom');
+    const obj = { a: 'x', b: 'y' };
+    router.subscribe(obj, '/a/b/');
+
+    trigger(obj, 'change:a');
+
+    expect(router.path).toBe('/x/y/');
+    expect(obj.b).toBe('y');
+  });
+
+  it('RT-2: on subscribe, a value after an empty part becomes null', async () => {
+    const Router = await freshRouter();
+    const router = new Router('custom');
+    const obj = { b: 'y', c: 'z' };
+    router.subscribe(obj, '/a/*/b/c/');
+
+    expect(router.path).toBe('/');
+    expect([obj.b, obj.c]).toEqual([null, null]);
+  });
+
+  it('RT-4: a route emptied on #!/x/ leaves the URL without a hash, in a new history entry', async () => {
+    history.replaceState(null, '', '/page?q=1#!/x/');
+    const Router = await freshRouter();
+    const obj = {};
+    Router.hash.subscribe(obj, '/a/');
+    await wait();
+    expect(obj.a).toBe('x');
+    const { length } = history;
+
+    obj.a = null;
+    await wait();
+
+    expect(location.href).toBe('http://localhost/page?q=1');
+    expect(history.length).toBe(length + 1);
+    expect(Router.hash.parts).toEqual([]);
+  });
+
+  it('DOC-1: Router.hash bound before any subscribe shows the URL and writes it back', async () => {
+    history.replaceState(null, '', '/#!/users/42/');
+    const Router = await freshRouter();
+    document.body.innerHTML = '<i class="current-path"></i>';
+    bindNode(Router.hash, 'path', '.current-path', binders.text());
+    await wait();
+    expect(document.querySelector('.current-path').textContent).toBe('/users/42/');
+
+    Router.hash.path = '/a/b/';
+    await wait();
+
+    expect(Router.hash.parts).toEqual(['a', 'b']);
+    expect(location.hash).toBe('#!/a/b/');
+  });
+
+  it('DOC-1: Router.history reads the URL before any subscribe; new Router(type) gives the singleton', async () => {
+    history.replaceState(null, '', '/users/42/');
+    const Router = await freshRouter();
+
+    expect(Router.history.parts).toEqual(['users', '42']);
+    expect(new Router('history')).toBe(Router.history);
+    expect(new Router('hash')).toBe(Router.hash);
+  });
+
+  it('ES5-7: a for-in over a router lists its data only (dist assigns the class methods)', async () => {
+    const Router = await freshRouter();
+
+    expect(forInKeys(new Router('audit'))).toEqual(['parts', 'path', 'hashPath', 'type']);
+    expect(Object.getOwnPropertyDescriptor(Router.prototype, 'init').enumerable).toBe(false);
+    expect(Object.getOwnPropertyDescriptor(Router.prototype, 'subscribe').enumerable).toBe(false);
+  });
+});

From e4d7e5d5281da74fac4855d401d91c457e34d423 Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:32:39 +0400
Subject: [PATCH 5/7] docs: sweep 5 samples

---
 docs/content/en/api/binders/progress.md       |   2 +-
 docs/content/en/api/binders/style.md          |   6 +-
 .../en/api/matreshka-array/item-renderer.md   |   2 +-
 .../en/api/matreshka-array/on-item-render.md  |   7 +-
 .../content/en/api/matreshka-array/restore.md |   3 +
 .../content/en/api/matreshka-array/to-json.md |   2 +-
 .../en/api/matreshka-array/track-by.md        |   2 +-
 docs/content/en/api/matreshka-static/class.md |   2 +-
 docs/content/en/api/matreshka/bind-node.md    |   2 +-
 docs/content/en/api/matreshka/instantiate.md  |   2 +-
 docs/content/en/api/matreshka/trigger.md      |   4 +-
 docs/content/en/api/types/matreshka.md        |   2 +-
 docs/content/en/faq.md                        |   6 +-
 docs/content/ru/api/binders/class-name.md     |  12 +-
 docs/content/ru/api/matreshka-array.md        |   2 +-
 .../ru/api/matreshka-array/item-renderer.md   |   7 +-
 .../ru/api/matreshka-array/on-item-render.md  |   7 +-
 .../content/ru/api/matreshka-array/restore.md |   3 +
 .../content/ru/api/matreshka-array/to-json.md |   2 +-
 docs/content/ru/api/matreshka-object.md       |   2 +-
 docs/content/ru/api/matreshka-object/each.md  |   2 +-
 .../ru/api/matreshka-static/parse-bindings.md |   6 +-
 docs/content/ru/api/matreshka/bind-node.md    |   7 +-
 docs/content/ru/api/matreshka/instantiate.md  |   2 +-
 docs/content/ru/api/matreshka/mediate.md      |   4 +-
 docs/content/ru/api/matreshka/off.md          |   4 +-
 .../ru/api/matreshka/parse-bindings.md        |   4 -
 docs/content/ru/api/matreshka/remove.md       |   4 +-
 docs/content/ru/api/matreshka/trigger.md      |   2 +-
 docs/content/ru/api/matreshka/unbind-node.md  |   8 +-
 docs/content/ru/api/types/binder.md           |   2 +-
 docs/content/ru/api/types/matreshka.md        |   2 +-
 docs/content/ru/faq.md                        |   8 +-
 docs/content/ru/index.md                      |   2 +-
 docs/content/ua/api/binders/class-name.md     |  12 +-
 docs/content/ua/api/binders/style.md          |   4 +-
 docs/content/ua/api/matreshka-array.md        |   2 +-
 .../ua/api/matreshka-array/item-renderer.md   |   7 +-
 .../ua/api/matreshka-array/on-item-render.md  |   7 +-
 .../content/ua/api/matreshka-array/restore.md |   3 +
 .../content/ua/api/matreshka-array/to-json.md |   2 +-
 .../ua/api/matreshka-array/track-by.md        |   2 +-
 docs/content/ua/api/matreshka-object.md       |   2 +-
 docs/content/ua/api/matreshka-object/each.md  |   2 +-
 .../ua/api/matreshka-static/parse-bindings.md |   6 +-
 docs/content/ua/api/matreshka/bind-node.md    |  25 +-
 docs/content/ua/api/matreshka/calc.md         |  14 +-
 docs/content/ua/api/matreshka/instantiate.md  |   4 +-
 docs/content/ua/api/matreshka/mediate.md      |   4 +-
 docs/content/ua/api/matreshka/off.md          |   6 +-
 .../ua/api/matreshka/parse-bindings.md        |   4 -
 docs/content/ua/api/matreshka/remove.md       |   4 +-
 docs/content/ua/api/matreshka/set.md          |   2 +-
 docs/content/ua/api/matreshka/trigger.md      |   2 +-
 docs/content/ua/api/matreshka/unbind-node.md  |   8 +-
 docs/content/ua/api/types/binder.md           |   2 +-
 docs/content/ua/api/types/matreshka.md        |   2 +-
 docs/content/ua/faq.md                        |   8 +-
 docs/content/ua/index.md                      |   2 +-
 docs/test/code-parity.test.js                 |  43 +++
 skills/matreshka/SKILL.md                     |   2 +-
 test/spec/regressions/sweep5_docs_spec.js     | 253 ++++++++++++++++++
 62 files changed, 439 insertions(+), 129 deletions(-)
 create mode 100644 docs/test/code-parity.test.js
 create mode 100644 test/spec/regressions/sweep5_docs_spec.js

diff --git a/docs/content/en/api/binders/progress.md b/docs/content/en/api/binders/progress.md
index bd3c0c52..276f739b 100644
--- a/docs/content/en/api/binders/progress.md
+++ b/docs/content/en/api/binders/progress.md
@@ -28,5 +28,5 @@ Returns a binder which binds an object property to a ``progress`` element value.
 ## Examples
 
 ```js
-this.bindNode('myKey', '.my-progres', Matreshka.binders.progress());
+this.bindNode('myKey', '.my-progress', Matreshka.binders.progress());
 ```
diff --git a/docs/content/en/api/binders/style.md b/docs/content/en/api/binders/style.md
index f965ecc0..8a86ef39 100644
--- a/docs/content/en/api/binders/style.md
+++ b/docs/content/en/api/binders/style.md
@@ -37,9 +37,9 @@ The property value can be transformed using ``mappingFn`` argument.
 ## Examples
 
 ```js
-this.bindNode('myKey', '.my-progres',
-        Matreshka.binders.style('backgroundColor'));
-this.myKey = 'red'; // background-color of .my-progress is red now
+this.bindNode('myKey', '.my-element',
+    Matreshka.binders.style('backgroundColor'));
+this.myKey = 'red'; // background-color of .my-element is red now
 ```
 
 **The usage of mapping function**
diff --git a/docs/content/en/api/matreshka-array/item-renderer.md b/docs/content/en/api/matreshka-array/item-renderer.md
index 828181fa..2c8d0958 100644
--- a/docs/content/en/api/matreshka-array/item-renderer.md
+++ b/docs/content/en/api/matreshka-array/item-renderer.md
@@ -277,7 +277,7 @@ But sometimes you just need to move an object across few collections without re-
 ```js
 this.push_(item, {
 	moveSandbox: true
-})
+});
 ```
 
 #### ``itemRenderer`` reassigning
diff --git a/docs/content/en/api/matreshka-array/on-item-render.md b/docs/content/en/api/matreshka-array/on-item-render.md
index bfbc3aac..efd7354f 100644
--- a/docs/content/en/api/matreshka-array/on-item-render.md
+++ b/docs/content/en/api/matreshka-array/on-item-render.md
@@ -23,7 +23,7 @@ At the same time ``onRender`` method is called in a rendered item with the only
 
 | Name | Type | Details |
 | --- | --- | --- |
-| `item` | [`object`](/api/types/object/) | A rendered node of a collection |
+| `item` | [`object`](/api/types/object/) | A rendered item of a collection |
 | `renderEvent` | [`object`](/api/types/object/) | ``"render"`` event object |
 
 ## Examples
@@ -44,7 +44,10 @@ class MyArray extends Matreshka.Array {
 		return MyModel;
 	}
 	itemRenderer() {
-		return '<li>'
+		return `<label>
+			<input type="checkbox" class="my-checkbox">
+			<span class="text"></span>
+		</label>`;
 	}
 	constructor() {
 		super().bindNode('sandbox', '.my-form');
diff --git a/docs/content/en/api/matreshka-array/restore.md b/docs/content/en/api/matreshka-array/restore.md
index 558543e2..34a403aa 100644
--- a/docs/content/en/api/matreshka-array/restore.md
+++ b/docs/content/en/api/matreshka-array/restore.md
@@ -41,6 +41,9 @@ class MyModel extends Matreshka.Object {
 }
 
 class MyCollection extends Matreshka.Array {
+	get Model() {
+		return MyModel;
+	}
 	get itemRenderer() {
 		return ':sandbox .renderer';
 	}
diff --git a/docs/content/en/api/matreshka-array/to-json.md b/docs/content/en/api/matreshka-array/to-json.md
index 7eba6e36..01002c34 100644
--- a/docs/content/en/api/matreshka-array/to-json.md
+++ b/docs/content/en/api/matreshka-array/to-json.md
@@ -28,7 +28,7 @@ The method works recursively, calling ``toJSON`` for all items which have such m
 ## Examples
 
 ```js
-const matreshkaArray = new Matreshka.Array(1, 2, new MatreshkaArray(3, 4));
+const matreshkaArray = new Matreshka.Array(1, 2, new Matreshka.Array(3, 4));
 
 // returns [1, 2, [3, 4]]
 console.log(matreshkaArray.toJSON());
diff --git a/docs/content/en/api/matreshka-array/track-by.md b/docs/content/en/api/matreshka-array/track-by.md
index 27a9598d..6942015d 100644
--- a/docs/content/en/api/matreshka-array/track-by.md
+++ b/docs/content/en/api/matreshka-array/track-by.md
@@ -44,7 +44,7 @@ arr.recreate([
 // the next recreate call
 // removes an object with _id: 0
 // adds an object with _id: 3
-// updates an object with _id: 3 (changes name from Bar to BarNew)
+// updates an object with _id: 1 (changes name from Bar to BarNew)
 // updates an object with _id: 2 (changes name from Baz to BazNew)
 // resorts collection
 arr.recreate([
diff --git a/docs/content/en/api/matreshka-static/class.md b/docs/content/en/api/matreshka-static/class.md
index a157d694..a7686d55 100644
--- a/docs/content/en/api/matreshka-static/class.md
+++ b/docs/content/en/api/matreshka-static/class.md
@@ -60,7 +60,7 @@ const C = Matreshka.Class({
 const D = Matreshka.Class({
 	// D is inherited from C
 	extends: C,
-	method3() {
+	method3(a, b) {
 		// calling the parent method
 		C.prototype.method3.apply(this, arguments);
 	}
diff --git a/docs/content/en/api/matreshka/bind-node.md b/docs/content/en/api/matreshka/bind-node.md
index ba1ec664..5b5ba881 100644
--- a/docs/content/en/api/matreshka/bind-node.md
+++ b/docs/content/en/api/matreshka/bind-node.md
@@ -120,7 +120,7 @@ const checkboxBinder = () => {
 // to the beginning of the Matreshka.defaultBinders array
 Matreshka.defaultBinders.unshift(node => {
 	// check if the element is a checkbox
-	if(node.tagName == 'INPUT' && node.type == 'checkbox') {
+	if(node.tagName === 'INPUT' && node.type === 'checkbox') {
 		// if checking is OK, return a new binder
 		return checkboxBinder();
 	}
diff --git a/docs/content/en/api/matreshka/instantiate.md b/docs/content/en/api/matreshka/instantiate.md
index e8ab3cef..fd73ec91 100644
--- a/docs/content/en/api/matreshka/instantiate.md
+++ b/docs/content/en/api/matreshka/instantiate.md
@@ -123,7 +123,7 @@ class AppData extends Matreshka.Object {
 		super(data)
 			.instantiate({
 				friends: Friends,
-				settins: Settings
+				settings: Settings
 			});
 	}
 }
diff --git a/docs/content/en/api/matreshka/trigger.md b/docs/content/en/api/matreshka/trigger.md
index a630e5f9..0b3b0103 100644
--- a/docs/content/en/api/matreshka/trigger.md
+++ b/docs/content/en/api/matreshka/trigger.md
@@ -10,7 +10,7 @@ importance: 1
 **Method**
 
 ```js
-Matreshka#trigger(names, [arg]) → matreshka
+Matreshka#trigger(names, [arg]) → object
 ```
 
 Fires an event
@@ -19,7 +19,7 @@ After adding event handlers using [`Matreshka#on`](/api/matreshka/on/), [`Matres
 
 > Note that the method has [static alternative](/api/matreshka-static/trigger/)
 
-**Returns:** [`matreshka`](/api/types/matreshka/) – self
+**Returns:** [`object`](/api/types/object/) – self
 
 ## Arguments
 
diff --git a/docs/content/en/api/types/matreshka.md b/docs/content/en/api/types/matreshka.md
index 4ab8c4ce..c2b078d8 100644
--- a/docs/content/en/api/types/matreshka.md
+++ b/docs/content/en/api/types/matreshka.md
@@ -15,5 +15,5 @@ importance: 2
 
 ```js
 const matreshka = new Matreshka();
-obj.calc('a', 'b');
+matreshka.calc('a', 'b');
 ```
diff --git a/docs/content/en/faq.md b/docs/content/en/faq.md
index 6dffb45a..2850239d 100644
--- a/docs/content/en/faq.md
+++ b/docs/content/en/faq.md
@@ -72,13 +72,13 @@ class User extends Matreshka.Object {
                 // pseudo-sandbox creation for syntax sugar at selectors
                 // (not required)
                 nodeA: node,
-                name: ':bound(nodeA) .name',
-                email: ':bound(nodeA) .email',
+                name: { node: ':bound(nodeA) .name', binder: Matreshka.binders.text() },
+                email: { node: ':bound(nodeA) .email', binder: Matreshka.binders.text() },
             });
         } else if(parentArray instanceof UsersB) {
             this.bindNode({
                 nodeB: node,
-                name: ':bound(nodeB) .user-name',
+                name: { node: ':bound(nodeB) .user-name', binder: Matreshka.binders.text() },
             });
         }
     }
diff --git a/docs/content/ru/api/binders/class-name.md b/docs/content/ru/api/binders/class-name.md
index 5ee7648f..5de40e84 100644
--- a/docs/content/ru/api/binders/class-name.md
+++ b/docs/content/ru/api/binders/class-name.md
@@ -36,18 +36,18 @@ Matreshka.binders.className(className, [bool=true]) → binder
 
 ```js
 this.bindNode('myKey', '.my-element',
-        Matreshka.binders.className('blah'));
+        Matreshka.binders.className('foo'));
 
-this.myKey = true; // добавляет класс 'blah'
+this.myKey = true; // добавляет класс 'foo'
 
-this.myKey = false; // убирает класс 'blah'
+this.myKey = false; // убирает класс 'foo'
 ```
 
 ```js
 this.bindNode('myKey', '.my-element',
-        Matreshka.binders.className('blah', false));
+        Matreshka.binders.className('foo', false));
 
-this.myKey = false; // добавляет класс 'blah'
+this.myKey = false; // добавляет класс 'foo'
 
-this.myKey = true; // убирает класс 'blah'
+this.myKey = true; // убирает класс 'foo'
 ```
diff --git a/docs/content/ru/api/matreshka-array.md b/docs/content/ru/api/matreshka-array.md
index 12a4938a..d27e7ccf 100644
--- a/docs/content/ru/api/matreshka-array.md
+++ b/docs/content/ru/api/matreshka-array.md
@@ -137,7 +137,7 @@ new Matreshka.Array(42);
 **Передача элементов при создании**
 
 ```js
-new Matreshka.Array('Hi', { a: 'b' });
+new Matreshka.Array('Hi', {a: 'b'});
 ```
 
 **Наследование**
diff --git a/docs/content/ru/api/matreshka-array/item-renderer.md b/docs/content/ru/api/matreshka-array/item-renderer.md
index 63f9f991..0d9dcbbc 100644
--- a/docs/content/ru/api/matreshka-array/item-renderer.md
+++ b/docs/content/ru/api/matreshka-array/item-renderer.md
@@ -32,9 +32,8 @@ class MyArray extends Matreshka.Array {
 	itemRenderer = '<li>';
 	get Model() { return MyModel; }
 	constructor() {
-        super();
 		// определяем песочницу
-		this.bindNode('sandbox', '.my-list');
+		super().bindNode('sandbox', '.my-list');
 	}
 }
 ```
@@ -197,7 +196,7 @@ const app = new MyArray();
 Не забывайте, что в Matreshka.js реализована возможность отлова делегированных событий. Т. е. сам массив может отловить событие рендеринга элемента, используя имя события ``*@render`` (см. документацию к [`eventNames`](/ru/api/types/event-names/)).
 ```js
 this.on('*@render', () => {
-	alert('Child element is rendered');
+	alert('Child item is rendered');
 });
 ```
 
@@ -275,7 +274,7 @@ this.push_(item, {
 #### Переопределение ``itemRenderer``
 При переустановке свойства ``itemRenderer``, коллекция автоматически перерисовывается.
 ```js
-this.itemRenderer = '<div>';
+this.itemRenderer = '<div class="new-renderer"></div>';
 ```
 Эта возможность полезна в том случае, когда разработчик желает загрузить шаблон с сервера.
 ```js
diff --git a/docs/content/ru/api/matreshka-array/on-item-render.md b/docs/content/ru/api/matreshka-array/on-item-render.md
index e5a81fc7..19463a59 100644
--- a/docs/content/ru/api/matreshka-array/on-item-render.md
+++ b/docs/content/ru/api/matreshka-array/on-item-render.md
@@ -23,7 +23,7 @@ Matreshka.Array#onItemRender(item, renderEvent)
 
 | Имя | Тип | Описание |
 | --- | --- | --- |
-| `item` | [`object`](/ru/api/types/object/) | Отрисованный элемент коллекции |
+| `item` | [`object`](/ru/api/types/object/) | Отрисованный объект коллекции |
 | `renderEvent` | [`object`](/ru/api/types/object/) | Объект события ``render`` |
 
 ## Примеры
@@ -44,7 +44,10 @@ class MyArray extends Matreshka.Array {
 		return MyModel;
 	}
 	itemRenderer() {
-		return '<li>'
+		return `<label>
+			<input type="checkbox" class="my-checkbox">
+			<span class="text"></span>
+		</label>`;
 	}
 	constructor() {
 		super().bindNode('sandbox', '.my-form');
diff --git a/docs/content/ru/api/matreshka-array/restore.md b/docs/content/ru/api/matreshka-array/restore.md
index 59553e22..ec59f212 100644
--- a/docs/content/ru/api/matreshka-array/restore.md
+++ b/docs/content/ru/api/matreshka-array/restore.md
@@ -41,6 +41,9 @@ class MyModel extends Matreshka.Object {
 }
 
 class MyCollection extends Matreshka.Array {
+	get Model() {
+		return MyModel;
+	}
 	get itemRenderer() {
 		return ':sandbox .renderer';
 	}
diff --git a/docs/content/ru/api/matreshka-array/to-json.md b/docs/content/ru/api/matreshka-array/to-json.md
index f01f2de7..24d29396 100644
--- a/docs/content/ru/api/matreshka-array/to-json.md
+++ b/docs/content/ru/api/matreshka-array/to-json.md
@@ -28,7 +28,7 @@ Matreshka.Array#toJSON([recursive=true]) → array
 ## Примеры
 
 ```js
-const matreshkaArray = new Matreshka.Array(1, 2, new MatreshkaArray(3, 4));
+const matreshkaArray = new Matreshka.Array(1, 2, new Matreshka.Array(3, 4));
 
 // возвращает [1, 2, [3, 4]]
 console.log(matreshkaArray.toJSON());
diff --git a/docs/content/ru/api/matreshka-object.md b/docs/content/ru/api/matreshka-object.md
index eda2e164..4364cd95 100644
--- a/docs/content/ru/api/matreshka-object.md
+++ b/docs/content/ru/api/matreshka-object.md
@@ -49,7 +49,7 @@ this.toJSON();
 При добавлении и изменении свойств, отвечающих за данные генерируется события ``set`` и ``modify``, при удалении - ``remove`` и ``modify``. Т. е. любые изменения данных можно слушать с помощью ``modify``.
 ```js
 this.on('modify', () => {
-	alert('Object is modified');
+	alert('an object is modified');
 });
 ```
 
diff --git a/docs/content/ru/api/matreshka-object/each.md b/docs/content/ru/api/matreshka-object/each.md
index 6f2b0d6c..70653026 100644
--- a/docs/content/ru/api/matreshka-object/each.md
+++ b/docs/content/ru/api/matreshka-object/each.md
@@ -34,7 +34,7 @@ this
 	.addDataKeys('c')
 	.each((value, key) => {
 		console.log(key, value);
-	});
+	}, this);
 ;
 // >>> a 1, b 2, c undefined
 ```
diff --git a/docs/content/ru/api/matreshka-static/parse-bindings.md b/docs/content/ru/api/matreshka-static/parse-bindings.md
index 757f8a38..91cd8088 100644
--- a/docs/content/ru/api/matreshka-static/parse-bindings.md
+++ b/docs/content/ru/api/matreshka-static/parse-bindings.md
@@ -33,8 +33,8 @@ Matreshka.parseBindings() → $nodes
 
 ```js
 const object = {};
-const $node = Matreshka.parseBindings(object, `<h3>
-        Hello, {{name}}
-    </h3>`);
+const $node = Matreshka.parseBindings(object, `
+    <h3>Hello, {{name}}</h3>
+`);
 object.name = 'World';
 ```
diff --git a/docs/content/ru/api/matreshka/bind-node.md b/docs/content/ru/api/matreshka/bind-node.md
index aab27dbc..4cce143f 100644
--- a/docs/content/ru/api/matreshka/bind-node.md
+++ b/docs/content/ru/api/matreshka/bind-node.md
@@ -148,7 +148,8 @@ const uiSlider = (min, max) => {
 		}
 	}
 };
-
+```
+```js
 this.bindNode('myKey1', '.my-slider1', uiSlider(0, 100));
 this.bindNode('myKey2', '.my-slider2', uiSlider(1, 1000));
 this.myKey1 = 42;
@@ -309,7 +310,7 @@ setTimeout(() => {
 Например, мы хотим связать ``input[type="text"]`` со свойством. По умолчанию, стандартный байндер для этого элемента содержит свойство ``"on"`` со значением ``"input"``. Это значит, что значение свойства экземпляра и состояние элемента будут синхронизированы сразу после ввода или удаления символа пользователем. В случае, если вы хотите, чтоб синхронизация происходила по DOM событию ``"blur"``, вам потребуется передать третьим аргументом объект, содержащий единственное свойство ``"on"``. Этот объект объединится со стандартным байндером, сохранив при этом значения ``getValue`` и ``setValue``.
 
 ```js
-this.bindNode('x', '.my-input', { on: "blur" });
+this.bindNode('myKey', '.my-input', { on: 'blur' });
 ```
 
 Для отмены этого поведения и использования байндера как он есть, в объект события можно передать флаг ``useExactBinder`` со значением ``true``.
@@ -317,7 +318,7 @@ this.bindNode('x', '.my-input', { on: "blur" });
 ```js
 this.bindNode('x', node, binder, {
 	useExactBinder: true
-})
+});
 ```
 
 **Возвращает:** [`object`](/ru/api/types/object/) – self
diff --git a/docs/content/ru/api/matreshka/instantiate.md b/docs/content/ru/api/matreshka/instantiate.md
index 471e6680..7f4f1742 100644
--- a/docs/content/ru/api/matreshka/instantiate.md
+++ b/docs/content/ru/api/matreshka/instantiate.md
@@ -92,7 +92,7 @@ class MyParentClass extends Matreshka {
 **Нестандартный способ использования ``updateCallback`` для игнорирования любых изменений свойства.**
 
 ```js
-this.instantiate('x', SubClass, () => {});
+this.instantiate('x', MyClass, () => {});
 ```
 
 **В случае, если ваш класс не подерживает использование оператора ``new``, вместо ``instantiate`` воспользуйтесь методом [`Matreshka#mediate`](/ru/api/matreshka/mediate/).**
diff --git a/docs/content/ru/api/matreshka/mediate.md b/docs/content/ru/api/matreshka/mediate.md
index 764e196a..66480013 100644
--- a/docs/content/ru/api/matreshka/mediate.md
+++ b/docs/content/ru/api/matreshka/mediate.md
@@ -10,7 +10,7 @@ importance: 2
 **Метод**
 
 ```js
-Matreshka#mediate(key, mediator)
+Matreshka#mediate(key, mediator) → object
 ```
 
 Трансформирует значение свойства при его изменении
@@ -25,6 +25,8 @@ mediate(object, key, mediator);
 // вместо this.mediate(key, mediator);
 ```
 
+**Возвращает:** [`object`](/ru/api/types/object/) – self
+
 ## Аргументы
 
 | Имя | Тип | Описание |
diff --git a/docs/content/ru/api/matreshka/off.md b/docs/content/ru/api/matreshka/off.md
index 7894a9f6..5bbdac13 100644
--- a/docs/content/ru/api/matreshka/off.md
+++ b/docs/content/ru/api/matreshka/off.md
@@ -10,7 +10,7 @@ importance: 1
 **Метод**
 
 ```js
-Matreshka#off([names], [callback], [context]) → matreshka
+Matreshka#off([names], [callback], [context]) → object
 ```
 
 Удаляет обработчик события
@@ -19,7 +19,7 @@ Matreshka#off([names], [callback], [context]) → matreshka
 
 Без аргументов ``off`` удаляет все обработчики, добавленные через ``on``, ``once`` и ``onDebounce``, и генерирует ``removeevent`` для каждого из них. Привязки, зависимости ``calc`` и внутренние события ``Matreshka.Object`` и ``Matreshka.Array`` остаются.
 
-**Возвращает:** [`matreshka`](/ru/api/types/matreshka/) – self
+**Возвращает:** [`object`](/ru/api/types/object/) – self
 
 **Генерирует события:** `removeevent`, `removeevent:NAME`
 
diff --git a/docs/content/ru/api/matreshka/parse-bindings.md b/docs/content/ru/api/matreshka/parse-bindings.md
index d8b86f38..02d69f45 100644
--- a/docs/content/ru/api/matreshka/parse-bindings.md
+++ b/docs/content/ru/api/matreshka/parse-bindings.md
@@ -38,15 +38,11 @@ JS: this.user = {name: 'Joe'}
 JS: this.x = 'some value';
 -->
 <input type="text" value="{{x}}">
-```
-```html
 <!--
 Для привязки textarea и select нужно использовать атрибут value
 -->
 <textarea value="{{x}}"></textarea>
 <select value="{{x}}">...</select>
-```
-```html
 <!--
 Свяжет свойство "x" экземпляра с чекбоксом
 (двусторонняя привязка)
diff --git a/docs/content/ru/api/matreshka/remove.md b/docs/content/ru/api/matreshka/remove.md
index 96152be7..a56b6332 100644
--- a/docs/content/ru/api/matreshka/remove.md
+++ b/docs/content/ru/api/matreshka/remove.md
@@ -10,14 +10,14 @@ importance: 3
 **Метод**
 
 ```js
-Matreshka#remove(key, [eventOptions]) → matreshka
+Matreshka#remove(key, [eventOptions]) → object
 ```
 
 Удаляет свойство
 
 > У метода есть [статичный аналог](/ru/api/matreshka-static/remove/).
 
-**Возвращает:** [`matreshka`](/ru/api/types/matreshka/) – self
+**Возвращает:** [`object`](/ru/api/types/object/) – self
 
 **Генерирует события:** `delete`, `delete:KEY`
 
diff --git a/docs/content/ru/api/matreshka/trigger.md b/docs/content/ru/api/matreshka/trigger.md
index 948ed168..9149b5ad 100644
--- a/docs/content/ru/api/matreshka/trigger.md
+++ b/docs/content/ru/api/matreshka/trigger.md
@@ -41,5 +41,5 @@ Matreshka#trigger(names, [arg]) → object
 this.on('foo bar', (a, b, c) => {
 	alert(a + b + c);
 });
-this.trigger('bar', 1, 2, 3); // alerts 6
+this.trigger('foo', 1, 2, 3); // alerts 6
 ```
diff --git a/docs/content/ru/api/matreshka/unbind-node.md b/docs/content/ru/api/matreshka/unbind-node.md
index 4ee7e4af..a7108a59 100644
--- a/docs/content/ru/api/matreshka/unbind-node.md
+++ b/docs/content/ru/api/matreshka/unbind-node.md
@@ -10,7 +10,7 @@ importance: 2
 **Метод**
 
 ```js
-Matreshka#unbindNode(key, [node], [eventOptions]) → matreshka
+Matreshka#unbindNode(key, [node], [eventOptions]) → object
 ```
 
 Разрывает связь между свойством и HTML элементом
@@ -19,7 +19,7 @@ Matreshka#unbindNode(key, [node], [eventOptions]) → matreshka
 
 Ключ с точками — это путь к вложенному свойству, как и в [`Matreshka#bindNode`](/ru/api/matreshka/bind-node/); с опцией события ``exactKey: true`` он используется как есть. ``null`` вместо ключа удаляет также привязки вложенных свойств (``"a.b"``).
 
-**Возвращает:** [`matreshka`](/ru/api/types/matreshka/) – self
+**Возвращает:** [`object`](/ru/api/types/object/) – self
 
 **Генерирует события:** `unbind`, `unbind:KEY`
 
@@ -48,10 +48,10 @@ this.myKey = false;
 ## Альтернативный синтаксис unbindNode, позволяющий передать объект с байндингами. См. Matreshka#bindNode(2) [#variation-2]
 
 ```js
-Matreshka#unbindNode(bindings, [eventOptions]) → matreshka
+Matreshka#unbindNode(bindings, [eventOptions]) → object
 ```
 
-**Возвращает:** [`matreshka`](/ru/api/types/matreshka/) – self
+**Возвращает:** [`object`](/ru/api/types/object/) – self
 
 ### Аргументы
 
diff --git a/docs/content/ru/api/types/binder.md b/docs/content/ru/api/types/binder.md
index da325edf..8ada01cb 100644
--- a/docs/content/ru/api/types/binder.md
+++ b/docs/content/ru/api/types/binder.md
@@ -47,7 +47,7 @@ this.bindNode('a', '.my-checkbox', binder);
 const binder = {
 	on(callback, bindingOptions) {
 		this.onclick = callback;
-	}
+	},
 	// ...
 };
 // ...
diff --git a/docs/content/ru/api/types/matreshka.md b/docs/content/ru/api/types/matreshka.md
index c9aa925b..e3717841 100644
--- a/docs/content/ru/api/types/matreshka.md
+++ b/docs/content/ru/api/types/matreshka.md
@@ -15,5 +15,5 @@ importance: 2
 
 ```js
 const matreshka = new Matreshka();
-obj.calc('a', 'b');
+matreshka.calc('a', 'b');
 ```
diff --git a/docs/content/ru/faq.md b/docs/content/ru/faq.md
index 84f130b4..61f371b5 100644
--- a/docs/content/ru/faq.md
+++ b/docs/content/ru/faq.md
@@ -25,7 +25,7 @@ function bindNode(object, key, node, binder) {
     node.addEventListener(binder.on, () => {
         value = binder.getValue.call(node);
     });
-};
+}
 ```
 Для упрощения, функция не поддерживает связь многие-ко-многим и другие фичи оригинала.
 
@@ -73,13 +73,13 @@ class User extends Matreshka.Object {
 				// для синтаксического сахара в селекторах
 				// (это не обязательно)
 				nodeA: node,
-				name: ':bound(nodeA) .name',
-				email: ':bound(nodeA) .email',
+				name: { node: ':bound(nodeA) .name', binder: Matreshka.binders.text() },
+				email: { node: ':bound(nodeA) .email', binder: Matreshka.binders.text() },
 			});
 		} else if(parentArray instanceof UsersB) {
 			this.bindNode({
 				nodeB: node,
-				name: ':bound(nodeB) .user-name',
+				name: { node: ':bound(nodeB) .user-name', binder: Matreshka.binders.text() },
 			});
 		}
 	}
diff --git a/docs/content/ru/index.md b/docs/content/ru/index.md
index 99fe0b8f..f9fcbde4 100644
--- a/docs/content/ru/index.md
+++ b/docs/content/ru/index.md
@@ -7,8 +7,8 @@ sidebarTitle: "Главная"
 # Matreshka.js
 
 ```html
-<output class="out"></output>
 <input class="in" type="text">
+<output class="out"></output>
 
 <script src="https://cdn.jsdelivr.net/npm/matreshka@3/dist/matreshka.min.js"></script>
 <script>
diff --git a/docs/content/ua/api/binders/class-name.md b/docs/content/ua/api/binders/class-name.md
index 93405b38..83bf8437 100644
--- a/docs/content/ua/api/binders/class-name.md
+++ b/docs/content/ua/api/binders/class-name.md
@@ -36,18 +36,18 @@ Matreshka.binders.className(className, [bool=true]) → binder
 
 ```js
 this.bindNode('myKey', '.my-element',
-        Matreshka.binders.className('blah'));
+        Matreshka.binders.className('foo'));
 
-this.myKey = true; // додає клас 'blah'
+this.myKey = true; // додає клас 'foo'
 
-this.myKey = false; // вбирає клас 'blah'
+this.myKey = false; // прибирає клас 'foo'
 ```
 
 ```js
 this.bindNode('myKey', '.my-element',
-        Matreshka.binders.className('blah', false));
+        Matreshka.binders.className('foo', false));
 
-this.myKey = false; // додає клас 'blah'
+this.myKey = false; // додає клас 'foo'
 
-this.myKey = true; // вбирає клас 'blah'
+this.myKey = true; // прибирає клас 'foo'
 ```
diff --git a/docs/content/ua/api/binders/style.md b/docs/content/ua/api/binders/style.md
index 3a1218d6..608a7ccc 100644
--- a/docs/content/ua/api/binders/style.md
+++ b/docs/content/ua/api/binders/style.md
@@ -37,9 +37,9 @@ Matreshka.binders.style(property, [mappingFn]) → binder
 ## Приклади
 
 ```js
-this.bindNode('myKey', '.my-node',
+this.bindNode('myKey', '.my-element',
     Matreshka.binders.style('backgroundColor'));
-this.myKey = 'red'; // колір фону .my-node став червоним
+this.myKey = 'red'; // колір фону .my-element став червоним
 ```
 
 **Використання ``mappingFn``**
diff --git a/docs/content/ua/api/matreshka-array.md b/docs/content/ua/api/matreshka-array.md
index 40f4b93f..84c310ac 100644
--- a/docs/content/ua/api/matreshka-array.md
+++ b/docs/content/ua/api/matreshka-array.md
@@ -136,7 +136,7 @@ new Matreshka.Array(42);
 **Передача елементів при створенні**
 
 ```js
-new Matreshka.Array('Hi', { a: 'b' });
+new Matreshka.Array('Hi', {a: 'b'});
 ```
 
 **Спадкування**
diff --git a/docs/content/ua/api/matreshka-array/item-renderer.md b/docs/content/ua/api/matreshka-array/item-renderer.md
index 0c992b32..b680a804 100644
--- a/docs/content/ua/api/matreshka-array/item-renderer.md
+++ b/docs/content/ua/api/matreshka-array/item-renderer.md
@@ -32,9 +32,8 @@ class MyArray extends Matreshka.Array {
 	itemRenderer = '<li>';
 	get Model() { return MyModel; }
 	constructor() {
-        super();
 		// визначаємо пісочницю
-		this.bindNode('sandbox', '.my-list');
+		super().bindNode('sandbox', '.my-list');
 	}
 }
 ```
@@ -197,7 +196,7 @@ const app = new MyArray();
 Не забувайте, що в Matreshka.js реалізована можливість вилову делегованих подій. Тобто сам масив може відловити подію рендеринга айтема, використовуючи ім'я події ``*@render`` (див. документацію до [`eventNames`](/ua/api/types/event-names/)).
 ```js
 this.on('*@render', () => {
-	alert('Child element is rendered');
+	alert('Child item is rendered');
 });
 ```
 
@@ -275,7 +274,7 @@ this.push_(item, {
 #### Перевизначення ``itemRenderer``
 При перевизначенні властивості ``itemRenderer``, колекція автоматично перемальовується.
 ```js
-this.itemRenderer = '<div>';
+this.itemRenderer = '<div class="new-renderer"></div>';
 ```
 Ця можливість корисна в тому випадку, коли розробник бажає завантажити шаблон з сервера.
 ```js
diff --git a/docs/content/ua/api/matreshka-array/on-item-render.md b/docs/content/ua/api/matreshka-array/on-item-render.md
index 02650e75..87b3950a 100644
--- a/docs/content/ua/api/matreshka-array/on-item-render.md
+++ b/docs/content/ua/api/matreshka-array/on-item-render.md
@@ -23,7 +23,7 @@ Matreshka.Array#onItemRender(item, renderEvent)
 
 | Ім'я | Тип | Опис |
 | --- | --- | --- |
-| `item` | [`object`](/ua/api/types/object/) | Елемент колекції |
+| `item` | [`object`](/ua/api/types/object/) | Відмальований об'єкт колекції |
 | `renderEvent` | [`object`](/ua/api/types/object/) | Об'єкт події ``render`` |
 
 ## Приклади
@@ -44,7 +44,10 @@ class MyArray extends Matreshka.Array {
 		return MyModel;
 	}
 	itemRenderer() {
-		return '<li>'
+		return `<label>
+			<input type="checkbox" class="my-checkbox">
+			<span class="text"></span>
+		</label>`;
 	}
 	constructor() {
 		super().bindNode('sandbox', '.my-form');
diff --git a/docs/content/ua/api/matreshka-array/restore.md b/docs/content/ua/api/matreshka-array/restore.md
index 14f1f8a7..82f24ddd 100644
--- a/docs/content/ua/api/matreshka-array/restore.md
+++ b/docs/content/ua/api/matreshka-array/restore.md
@@ -41,6 +41,9 @@ class MyModel extends Matreshka.Object {
 }
 
 class MyCollection extends Matreshka.Array {
+	get Model() {
+		return MyModel;
+	}
 	get itemRenderer() {
 		return ':sandbox .renderer';
 	}
diff --git a/docs/content/ua/api/matreshka-array/to-json.md b/docs/content/ua/api/matreshka-array/to-json.md
index 14d7fad0..23f8ef20 100644
--- a/docs/content/ua/api/matreshka-array/to-json.md
+++ b/docs/content/ua/api/matreshka-array/to-json.md
@@ -28,7 +28,7 @@ Matreshka.Array#toJSON([recursive=true]) → array
 ## Приклади
 
 ```js
-const matreshkaArray = new Matreshka.Array(1, 2, new MatreshkaArray(3, 4));
+const matreshkaArray = new Matreshka.Array(1, 2, new Matreshka.Array(3, 4));
 
 // повертає [1, 2, [3, 4]]
 console.log(matreshkaArray.toJSON());
diff --git a/docs/content/ua/api/matreshka-array/track-by.md b/docs/content/ua/api/matreshka-array/track-by.md
index 4df18ca8..aadd3afa 100644
--- a/docs/content/ua/api/matreshka-array/track-by.md
+++ b/docs/content/ua/api/matreshka-array/track-by.md
@@ -34,7 +34,7 @@ class MyArray extends Matreshka.Array {
 
 const arr = new MyArray();
 
-// додає два об'єкти в масив
+// додає три об'єкти в масив
 arr.recreate([
 	{_id: 0, name: 'Foo'},
 	{_id: 1, name: 'Bar'},
diff --git a/docs/content/ua/api/matreshka-object.md b/docs/content/ua/api/matreshka-object.md
index dac3b490..f3a34c69 100644
--- a/docs/content/ua/api/matreshka-object.md
+++ b/docs/content/ua/api/matreshka-object.md
@@ -49,7 +49,7 @@ this.toJSON();
 При додаванні і зміні властивостей, що відповідають за дані генеруються події ``set`` і ``modify``, при видаленні - ``remove`` і ``modify``. Тобто будь-які зміни даних можна слухати за допомогою ``modify``.
 ```js
 this.on('modify', () => {
-	alert('Object is modified');
+	alert('an object is modified');
 });
 ```
 
diff --git a/docs/content/ua/api/matreshka-object/each.md b/docs/content/ua/api/matreshka-object/each.md
index 3ca637df..14377559 100644
--- a/docs/content/ua/api/matreshka-object/each.md
+++ b/docs/content/ua/api/matreshka-object/each.md
@@ -34,7 +34,7 @@ this
 	.addDataKeys('c')
 	.each((value, key) => {
 		console.log(key, value);
-	});
+	}, this);
 ;
 // >>> a 1, b 2, c undefined
 ```
diff --git a/docs/content/ua/api/matreshka-static/parse-bindings.md b/docs/content/ua/api/matreshka-static/parse-bindings.md
index 783d99b2..64151de7 100644
--- a/docs/content/ua/api/matreshka-static/parse-bindings.md
+++ b/docs/content/ua/api/matreshka-static/parse-bindings.md
@@ -33,8 +33,8 @@ Matreshka.parseBindings() → $nodes
 
 ```js
 const object = {};
-const $node = Matreshka.parseBindings(object, `<h3>
-        Hello, {{name}}
-    </h3>`);
+const $node = Matreshka.parseBindings(object, `
+    <h3>Hello, {{name}}</h3>
+`);
 object.name = 'World';
 ```
diff --git a/docs/content/ua/api/matreshka/bind-node.md b/docs/content/ua/api/matreshka/bind-node.md
index 07132a13..48fd29d6 100644
--- a/docs/content/ua/api/matreshka/bind-node.md
+++ b/docs/content/ua/api/matreshka/bind-node.md
@@ -33,8 +33,8 @@ bindNode(object, key, node, binder, eventOptions);
 ```js
 this.bindNode('myKey', '.my-element', {
 	on: 'click',
-	getValue () {...},
-	setValue () {...}
+	getValue() { ... },
+	setValue() { ... }
 });
 ```
 
@@ -52,7 +52,7 @@ this.bindNode('myKey', '.my-checkbox', {
 	// Як встановити стан елемента?
 	// - Встановити значення 'checked'
 	setValue(v) {
-		this.checked = !! v;
+		this.checked = !!v;
 	}
 });
 ```
@@ -108,11 +108,11 @@ this.bindNode('myKey', '.my-element');
 const checkboxBinder = () => {
 	return {
 		on: 'click',
-		getValue () {
+		getValue() {
 			return this.checked;
 		},
-		setValue (v) {
-			this.checked = !! v;
+		setValue(v) {
+			this.checked = !!v;
 		}
 	}
 };
@@ -121,7 +121,7 @@ const checkboxBinder = () => {
 // у початок масиву Matreshka.defaultBinders
 Matreshka.defaultBinders.unshift(node => {
 	// Перевіряємо, чи це чекбокс
-	if (node.tagName === 'INPUT' && node.type === 'checkbox') {
+	if(node.tagName === 'INPUT' && node.type === 'checkbox') {
 		// Якщо перевірка пройдена, повертаємо новий байндер
 		return checkboxBinder();
 	}
@@ -149,7 +149,8 @@ const uiSlider = (min, max) => {
 		}
 	}
 };
-
+```
+```js
 this.bindNode('myKey1', '.my-slider1', uiSlider(0, 100));
 this.bindNode('myKey2', '.my-slider2', uiSlider(1, 1000));
 this.myKey1 = 42;
@@ -187,10 +188,10 @@ this.bindNode('myAnotherKey', ':bound(myKey) .my-inner-element');
 this.bindNode('myKey', '.my-element');
 
 // Відловити клік на елементі .my-element
-this.on('click::myKey', () => {...});
+this.on('click::myKey', () => { ... });
 
 // Відловити клік на елементі .my-element .my-inner-element
-this.on('click::myKey(.my-inner-element)', () => {...});
+this.on('click::myKey(.my-inner-element)', () => { ... });
 ```
 
 > Якщо елемент не знайдений, кидається виняток ``Binding error: node is missing for key "KEY"``. Для того, щоб уникнути помилки використовуйте метод [`Matreshka#bindOptionalNode`](/ua/api/matreshka/bind-optional-node/)
@@ -223,7 +224,7 @@ this.bindNode('sandbox', '.my-sandbox');
 this.bindNode('myKey', ':sandbox .my-element');
 
 // Для делегованих подій всередині пісочниці не потрібно вказувати ключ
-this.on('click::(.my-button)', () => {...});
+this.on('click::(.my-button)', () => { ... });
 
 // Виведе в консоль елемент .inner-node,
 // Який знаходиться всередині пісочниці
@@ -310,7 +311,7 @@ setTimeout(() => {
 Наприклад, ми хочемо зв'язати ``input[type="text"]`` з властивістю. За замовчуванням, стандартний байндер для цього елемента містить властивість ``"on"`` зі значенням ``"input"``. Це означає, що значення властивості об'єкта і стан елемента будуть синхронізовані відразу після введення або видалення символу користувачем. У разі, якщо ви хочете, щоб синхронізація відбувалася після DOM події ``"blur"``, вам буде потрібно передати третім аргументом об'єкт, що містить єдину властивість ``"on"``. Цей об'єкт об'єднається зі стандартним байндером, зберігши при цьому значення ``getValue`` і ``setValue``.
 
 ```js
-this.bindNode('x', '.my-input', { on: "blur" });
+this.bindNode('myKey', '.my-input', { on: 'blur' });
 ```
 
 Для скасування цієї поведінки і використання байндера як він є, в об'єкт події можна передати прапор ``useExactBinder`` зі значенням ``true``.
diff --git a/docs/content/ua/api/matreshka/calc.md b/docs/content/ua/api/matreshka/calc.md
index 0cb3515b..9bbfe3b2 100644
--- a/docs/content/ua/api/matreshka/calc.md
+++ b/docs/content/ua/api/matreshka/calc.md
@@ -71,7 +71,7 @@ const someObject = {
 	c: 2,
 	d: 3
 };
-this.calc ('a', {
+this.calc('a', {
 	object: someObject,
 	key: ['b', 'c', 'd']
 }, (b, c, d) => b + c + d);
@@ -227,11 +227,11 @@ this.b = 1;
 this.c = 2;
 this.d = 3;
 
-this.calc ('a', ['b', 'c', 'd'], (b, c, d) => b + c + d, {
+this.calc('a', ['b', 'c', 'd'], (b, c, d) => b + c + d, {
 	debounceCalc: false
 });
 
-this.on('change: a', () => {
+this.on('change:a', () => {
 	// Обробник буде викликаний тричі,
 	// кожен раз коли властивості b, c чи d змінюються
 
@@ -259,7 +259,7 @@ this.b = 1;
 this.c = 2;
 this.d = 3;
 
-this.calc ('a', ['b', 'c', 'd'], (b, c, d) => b + c + d, {
+this.calc('a', ['b', 'c', 'd'], (b, c, d) => b + c + d, {
     debounceCalcOnInit: true
 });
 
@@ -365,12 +365,12 @@ this.b = 4;
 
 this
     .calc('p', ['a', 'b'], (a, b) => (a + b) * 2)
-    .calc('a', ['p', 'b'], (p, b) => p / 2 - b)
-    .calc('b', ['p', 'a'], (p, a) => p / 2 - a);
+    .calc('a', ['p', 'b'], (p, b) => p/2 - b)
+    .calc('b', ['p', 'a'], (p, a) => p/2 - a);
 
 alert(this.p); // 14
 
-this.on('change: p', () => {
+this.on('change:p', () => {
     // "периметр змінений і дорівнює 18"
     console.log(`периметр змінений і дорівнює ${this.p}`);
 });
diff --git a/docs/content/ua/api/matreshka/instantiate.md b/docs/content/ua/api/matreshka/instantiate.md
index 5d061cfe..67e6ea64 100644
--- a/docs/content/ua/api/matreshka/instantiate.md
+++ b/docs/content/ua/api/matreshka/instantiate.md
@@ -92,7 +92,7 @@ class MyParentClass extends Matreshka {
 **Нестандартний спосіб використання ``updateCallback`` для ігнорування будь-яких змін властивості**
 
 ```js
-this.instantiate('x', SubClass, () => {});
+this.instantiate('x', MyClass, () => {});
 ```
 
 **У разі, якщо ваш клас не підтримує використання оператора ``new``, замість ``instantiate`` скористайтеся методом [`Matreshka#mediate`](/ua/api/matreshka/mediate/).**
@@ -123,7 +123,7 @@ class AppData extends Matreshka.Object {
 		super(data)
 			.instantiate({
 				friends: Friends,
-				settins: Settings
+				settings: Settings
 			});
 	}
 }
diff --git a/docs/content/ua/api/matreshka/mediate.md b/docs/content/ua/api/matreshka/mediate.md
index d5c230ac..5ce87ff1 100644
--- a/docs/content/ua/api/matreshka/mediate.md
+++ b/docs/content/ua/api/matreshka/mediate.md
@@ -10,7 +10,7 @@ importance: 2
 **Метод**
 
 ```js
-Matreshka#mediate(key, mediator)
+Matreshka#mediate(key, mediator) → object
 ```
 
 Трансформує значення властивості при його зміні
@@ -25,6 +25,8 @@ mediate(object, key, mediator);
 // Замість this.mediate(key, mediator);
 ```
 
+**Повертає:** [`object`](/ua/api/types/object/) – self
+
 ## Аргументи
 
 | Ім'я | Тип | Опис |
diff --git a/docs/content/ua/api/matreshka/off.md b/docs/content/ua/api/matreshka/off.md
index 19d2cafb..e003cc58 100644
--- a/docs/content/ua/api/matreshka/off.md
+++ b/docs/content/ua/api/matreshka/off.md
@@ -10,7 +10,7 @@ importance: 1
 **Метод**
 
 ```js
-Matreshka#off([names], [callback], [context]) → matreshka
+Matreshka#off([names], [callback], [context]) → object
 ```
 
 Видаляє обробник події
@@ -19,7 +19,7 @@ Matreshka#off([names], [callback], [context]) → matreshka
 
 Без аргументів ``off`` видаляє всі обробники, додані через ``on``, ``once`` і ``onDebounce``, і генерує ``removeevent`` для кожного з них. Прив'язки, залежності ``calc`` і внутрішні події ``Matreshka.Object`` та ``Matreshka.Array`` залишаються.
 
-**Повертає:** [`matreshka`](/ua/api/types/matreshka/) – self
+**Повертає:** [`object`](/ua/api/types/object/) – self
 
 **Генерує події:** `removeevent`, `removeevent:NAME`
 
@@ -53,7 +53,7 @@ this.off();
 **Видалення події з певним обробником**
 
 ```js
-const handler = function () {
+const handler = function() {
 	// ...
 }
 this.on('change:x', handler);
diff --git a/docs/content/ua/api/matreshka/parse-bindings.md b/docs/content/ua/api/matreshka/parse-bindings.md
index 198d2903..ea67aae2 100644
--- a/docs/content/ua/api/matreshka/parse-bindings.md
+++ b/docs/content/ua/api/matreshka/parse-bindings.md
@@ -38,15 +38,11 @@ JS: this.user = {name: 'Joe'}
 JS: this.x = 'some value';
 -->
 <input type="text" value="{{x}}">
-```
-```html
 <!--
 Для прив'язки textarea і select потрібно використовувати атрибут value
 -->
 <textarea value="{{x}}"></textarea>
 <select value="{{x}}">...</select>
-```
-```html
 <!--
 Зв'яже властивість "x" об'єкту з чекбоксом
 (двостороння прив'язка)
diff --git a/docs/content/ua/api/matreshka/remove.md b/docs/content/ua/api/matreshka/remove.md
index 53d6fff6..51a57a14 100644
--- a/docs/content/ua/api/matreshka/remove.md
+++ b/docs/content/ua/api/matreshka/remove.md
@@ -10,14 +10,14 @@ importance: 3
 **Метод**
 
 ```js
-Matreshka#remove(key, [eventOptions]) → matreshka
+Matreshka#remove(key, [eventOptions]) → object
 ```
 
 Видаляє властивість
 
 > У метода є [статичний аналог](/ua/api/matreshka-static/remove/).
 
-**Повертає:** [`matreshka`](/ua/api/types/matreshka/) – self
+**Повертає:** [`object`](/ua/api/types/object/) – self
 
 **Генерує події:** `delete`, `delete:KEY`
 
diff --git a/docs/content/ua/api/matreshka/set.md b/docs/content/ua/api/matreshka/set.md
index 0ee5c8e7..7d354290 100644
--- a/docs/content/ua/api/matreshka/set.md
+++ b/docs/content/ua/api/matreshka/set.md
@@ -38,7 +38,7 @@ Matreshka#set(key, value, [eventOptions])
 ## Приклади
 
 ```js
-this.on('change: myKey', evt => {
+this.on('change:myKey', evt => {
 	alert(evt.value);
 });
 
diff --git a/docs/content/ua/api/matreshka/trigger.md b/docs/content/ua/api/matreshka/trigger.md
index 9ca8f199..7c3bf86b 100644
--- a/docs/content/ua/api/matreshka/trigger.md
+++ b/docs/content/ua/api/matreshka/trigger.md
@@ -41,5 +41,5 @@ Matreshka#trigger(names, [arg]) → object
 this.on('foo bar', (a, b, c) => {
 	alert(a + b + c);
 });
-this.trigger('bar', 1, 2, 3); // alerts 6
+this.trigger('foo', 1, 2, 3); // alerts 6
 ```
diff --git a/docs/content/ua/api/matreshka/unbind-node.md b/docs/content/ua/api/matreshka/unbind-node.md
index e64bdfd7..0e64fc0f 100644
--- a/docs/content/ua/api/matreshka/unbind-node.md
+++ b/docs/content/ua/api/matreshka/unbind-node.md
@@ -10,7 +10,7 @@ importance: 2
 **Метод**
 
 ```js
-Matreshka#unbindNode(key, [node], [eventOptions]) → matreshka
+Matreshka#unbindNode(key, [node], [eventOptions]) → object
 ```
 
 Розриває зв'язок між властивістю і HTML елементом
@@ -19,7 +19,7 @@ Matreshka#unbindNode(key, [node], [eventOptions]) → matreshka
 
 Ключ з крапками — це шлях до вкладеної властивості, як і в [`Matreshka#bindNode`](/ua/api/matreshka/bind-node/); з опцією події ``exactKey: true`` він використовується як є. ``null`` замість ключа видаляє також прив'язки вкладених властивостей (``"a.b"``).
 
-**Повертає:** [`matreshka`](/ua/api/types/matreshka/) – self
+**Повертає:** [`object`](/ua/api/types/object/) – self
 
 **Генерує події:** `unbind`, `unbind:KEY`
 
@@ -48,10 +48,10 @@ this.myKey = false;
 ## Альтернативний синтаксис unbindNode, що дозволяє передати об'єкт з байндінгамі. Див. Matreshka#bindNode(2) [#variation-2]
 
 ```js
-Matreshka#unbindNode(bindings, [eventOptions]) → matreshka
+Matreshka#unbindNode(bindings, [eventOptions]) → object
 ```
 
-**Повертає:** [`matreshka`](/ua/api/types/matreshka/) – self
+**Повертає:** [`object`](/ua/api/types/object/) – self
 
 ### Аргументи
 
diff --git a/docs/content/ua/api/types/binder.md b/docs/content/ua/api/types/binder.md
index 2c792ee6..eafe8ee5 100644
--- a/docs/content/ua/api/types/binder.md
+++ b/docs/content/ua/api/types/binder.md
@@ -47,7 +47,7 @@ this.bindNode('a', '.my-checkbox', binder);
 const binder = {
 	on(callback, bindingOptions) {
 		this.onclick = callback;
-	}
+	},
 	// ...
 };
 // ...
diff --git a/docs/content/ua/api/types/matreshka.md b/docs/content/ua/api/types/matreshka.md
index fb9c92d8..36221c08 100644
--- a/docs/content/ua/api/types/matreshka.md
+++ b/docs/content/ua/api/types/matreshka.md
@@ -15,5 +15,5 @@ importance: 2
 
 ```js
 const matreshka = new Matreshka();
-obj.calc('a', 'b');
+matreshka.calc('a', 'b');
 ```
diff --git a/docs/content/ua/faq.md b/docs/content/ua/faq.md
index d3d92668..7c10c6b9 100644
--- a/docs/content/ua/faq.md
+++ b/docs/content/ua/faq.md
@@ -25,7 +25,7 @@ function bindNode(object, key, node, binder) {
     node.addEventListener(binder.on, () => {
         value = binder.getValue.call(node);
     });
-};
+}
 ```
 Для спрощення, функція не підтримує зв'язок багато-до-багатьох і інші фічі оригіналу.
 
@@ -73,13 +73,13 @@ class User extends Matreshka.Object {
 				// для синтаксичного цукру в селекторах
 				// (це не обов'язково)
 				nodeA: node,
-				name: ':bound(nodeA) .name',
-				email: ':bound(nodeA) .email',
+				name: { node: ':bound(nodeA) .name', binder: Matreshka.binders.text() },
+				email: { node: ':bound(nodeA) .email', binder: Matreshka.binders.text() },
 			});
 		} else if(parentArray instanceof UsersB) {
 			this.bindNode({
 				nodeB: node,
-				name: ':bound(nodeB) .user-name',
+				name: { node: ':bound(nodeB) .user-name', binder: Matreshka.binders.text() },
 			});
 		}
 	}
diff --git a/docs/content/ua/index.md b/docs/content/ua/index.md
index 42bc641c..74403c06 100644
--- a/docs/content/ua/index.md
+++ b/docs/content/ua/index.md
@@ -7,8 +7,8 @@ sidebarTitle: "Головна"
 # Matreshka.js
 
 ```html
-<output class="out"></output>
 <input class="in" type="text">
+<output class="out"></output>
 
 <script src="https://cdn.jsdelivr.net/npm/matreshka@3/dist/matreshka.min.js"></script>
 <script>
diff --git a/docs/test/code-parity.test.js b/docs/test/code-parity.test.js
new file mode 100644
index 00000000..172dfba0
--- /dev/null
+++ b/docs/test/code-parity.test.js
@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { pages } from './pages';
+
+// Code blocks of a page, comments dropped, each line trimmed with spaces collapsed, blank lines dropped.
+const codeBlocks = (md) =>
+  [...md.matchAll(/^(`{3,})(\S*)[^\n]*\n([\s\S]*?)^\1[ \t]*$/gm)].map(([, , lang, code]) => ({
+    lang,
+    lines: code
+      .replace(/<!--[\s\S]*?-->/g, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/(^|[\s;{}(),])\/\/.*$/gm, '$1')
+      .split('\n')
+      .map((line) => line.trim().replace(/[ \t]+/g, ' '))
+      .filter(Boolean)
+  }));
+
+// Strings and HTML text, the parts a translation may change.
+const maskText = (line) => line.replace(/(['"`])(?:\\.|(?!\1).)*\1/g, '$1$1').replace(/>[^<>]*</g, '><');
+const CYRILLIC = /\p{Script=Cyrillic}/u;
+
+describe('docs code blocks', () => {
+  // A translated page shows the same code as the English one; only comments and text in strings are translated.
+  it('are the same code in every language', () => {
+    const english = new Map(pages.filter(({ lang }) => lang === 'en').map((page) => [page.name, codeBlocks(page.md)]));
+    for (const { file, name, lang, md } of pages) {
+      if (lang === 'en') continue;
+      const blocks = codeBlocks(md);
+      const expected = english.get(name);
+      expect(
+        blocks.map((block) => block.lang),
+        `${file}: code blocks`
+      ).toEqual(expected.map((block) => block.lang));
+      blocks.forEach((block, i) => {
+        expect(block.lines.length, `${file}, block ${i + 1}: lines`).toBe(expected[i].lines.length);
+        block.lines.forEach((line, j) => {
+          const en = expected[i].lines[j];
+          const translated = line !== en && CYRILLIC.test(line) && maskText(line) === maskText(en);
+          if (!translated) expect(line, `${file}, block ${i + 1}, line ${j + 1}`).toBe(en);
+        });
+      });
+    }
+  });
+});
diff --git a/skills/matreshka/SKILL.md b/skills/matreshka/SKILL.md
index aadd650c..90c9070b 100644
--- a/skills/matreshka/SKILL.md
+++ b/skills/matreshka/SKILL.md
@@ -47,7 +47,7 @@ It weighs about 73 kB minified, 24 kB gzipped, 21 kB with brotli (what a CDN sen
 
 ### B. CDN ES module, no bundler
 
-`matreshka.min.mjs` is the whole library as one minified ES module: every named export of `matreshka` plus `initRouter`, `Router` and `parseForm`, and the default export is `Matreshka` with them attached. One request, the same size as the script-tag file.
+`matreshka.min.mjs` is the whole library as one minified ES module: every named export of `matreshka` plus `initRouter`, `Router` and `parseForm`, and the default export is `Matreshka` with them attached. One request, a little smaller than the script-tag file: it is not compiled down to ES5.
 
 ```html
 <script type="module">
diff --git a/test/spec/regressions/sweep5_docs_spec.js b/test/spec/regressions/sweep5_docs_spec.js
new file mode 100644
index 00000000..ccee62d8
--- /dev/null
+++ b/test/spec/regressions/sweep5_docs_spec.js
@@ -0,0 +1,253 @@
+import Matreshka from 'src/bundle';
+
+// The docs samples as the pages print them now, checked against what their comments say.
+const wait = async () => {
+  for (let i = 0; i < 5; i++) await new Promise((resolve) => setTimeout(resolve, 0));
+};
+const $ = (selector) => document.querySelector(selector);
+
+afterEach(() => {
+  document.body.innerHTML = '';
+});
+
+describe('docs samples, sweep 5', () => {
+  it('DOC-2 faq.md: one object in two collections changes both bound nodes', async () => {
+    document.body.innerHTML = '<ul class="a"></ul><ul class="b"></ul>';
+    let UsersA;
+    let UsersB;
+    class User extends Matreshka.Object {
+      constructor() {
+        super();
+        this.bindRenderedAsSandbox = false;
+      }
+      onRender(evt) {
+        const { parentArray, node } = evt;
+        if (parentArray instanceof UsersA) {
+          this.bindNode({
+            nodeA: node,
+            name: { node: ':bound(nodeA) .name', binder: Matreshka.binders.text() },
+            email: { node: ':bound(nodeA) .email', binder: Matreshka.binders.text() }
+          });
+        } else if (parentArray instanceof UsersB) {
+          this.bindNode({
+            nodeB: node,
+            name: { node: ':bound(nodeB) .user-name', binder: Matreshka.binders.text() }
+          });
+        }
+      }
+    }
+    UsersA = class extends Matreshka.Array {
+      get Model() {
+        return User;
+      }
+      itemRenderer = '<li><span class="name"></span><span class="email"></span></li>';
+      constructor() {
+        super().bindNode('sandbox', '.a');
+      }
+    };
+    UsersB = class extends Matreshka.Array {
+      get Model() {
+        return User;
+      }
+      itemRenderer = '<li><span class="user-name"></span></li>';
+      constructor() {
+        super().bindNode('sandbox', '.b');
+      }
+    };
+    const user = new User();
+    new UsersA().push(user);
+    new UsersB().push(user);
+    await wait();
+    user.name = 0.5;
+    user.email = 'x@example.com';
+    await wait();
+    expect($('.name').textContent).toBe('0.5');
+    expect($('.email').textContent).toBe('x@example.com');
+    expect($('.user-name').textContent).toBe('0.5');
+  });
+
+  it('DOC-3 restore.md: the restored items and the pushed one come out of toJSON', async () => {
+    document.body.innerHTML = `<ul class="collection-node">
+      <li>One</li><li>Two</li><li>Three</li>
+      <script type="text/html" class="renderer"><li></li></script>
+    </ul>`;
+    class MyModel extends Matreshka.Object {
+      constructor(data) {
+        super(data);
+        this.addDataKeys('value');
+      }
+      onRender() {
+        this.bindNode('value', ':sandbox', Matreshka.binders.html());
+      }
+    }
+    class MyCollection extends Matreshka.Array {
+      get Model() {
+        return MyModel;
+      }
+      get itemRenderer() {
+        return ':sandbox .renderer';
+      }
+      constructor() {
+        super().bindNode('sandbox', '.collection-node').restore(':sandbox li');
+      }
+    }
+    const myCollection = new MyCollection();
+    myCollection.push({ value: 'Four' });
+    await wait();
+    expect(myCollection.toJSON()).toEqual([{ value: 'One' }, { value: 'Two' }, { value: 'Three' }, { value: 'Four' }]);
+    expect($('.collection-node').querySelectorAll('li').length).toBe(4);
+  });
+
+  it('DOC-4 instantiate.md: new appData keeps the structure, settings included', () => {
+    class Credentials extends Matreshka.Object {}
+    class Settings extends Matreshka.Object {
+      constructor(data) {
+        super(data).instantiate('credentials', Credentials);
+      }
+    }
+    class Friend extends Matreshka.Object {}
+    class Friends extends Matreshka.Array {
+      get Model() {
+        return Friend;
+      }
+      trackBy = 'id';
+      constructor(data) {
+        super(...data);
+      }
+    }
+    class AppData extends Matreshka.Object {
+      constructor(data) {
+        super(data).instantiate({
+          friends: Friends,
+          settings: Settings
+        });
+      }
+    }
+    class App extends Matreshka {
+      constructor(appData) {
+        super();
+        this.appData = appData;
+        this.instantiate('appData', AppData);
+      }
+    }
+    const app = new App({
+      settings: { name: 'Vasiliy Vasiliev', credentials: { email: 'vasia.vasia@gmail.com' } },
+      friends: [
+        { name: 'Yulia Zuyeva', id: 1 },
+        { name: 'Konstantin Konstantinopolsky', id: 2 },
+        { name: 'nagibator3000', id: 3 }
+      ]
+    });
+    const { settings } = app.appData;
+    const { credentials } = settings;
+    const [yulia] = app.appData.friends;
+    expect(settings).toBeInstanceOf(Settings);
+    expect(credentials).toBeInstanceOf(Credentials);
+
+    app.appData = {
+      settings: { name: 'Petr Petrov', credentials: { email: 'petr.petrov@gmail.com' } },
+      friends: [
+        { name: 'Yulechka Zuyeva', id: 1 },
+        { name: 'Konstantin Konstantinopolsky', id: 2 }
+      ]
+    };
+    expect(app.appData.settings).toBe(settings);
+    expect(app.appData.settings.credentials).toBe(credentials);
+    expect(settings.name).toBe('Petr Petrov');
+    expect(credentials.email).toBe('petr.petrov@gmail.com');
+    expect(app.appData.friends[0]).toBe(yulia);
+    expect(app.appData.friends.length).toBe(2);
+  });
+
+  it('DOC-5 on-item-render.md: onRender binds the checkbox and the text of the rendered item', async () => {
+    document.body.innerHTML = '<form class="my-form"></form>';
+    const items = [];
+    class MyModel extends Matreshka.Object {
+      onRender() {
+        this.bindNode('isChecked', ':sandbox .my-checkbox');
+        this.bindNode('text', ':sandbox .text', Matreshka.binders.html());
+      }
+    }
+    class MyArray extends Matreshka.Array {
+      get Model() {
+        return MyModel;
+      }
+      itemRenderer() {
+        return `<label>
+          <input type="checkbox" class="my-checkbox">
+          <span class="text"></span>
+        </label>`;
+      }
+      constructor() {
+        super().bindNode('sandbox', '.my-form');
+      }
+      onItemRender(item) {
+        items.push(item);
+      }
+    }
+    const app = new MyArray();
+    app.push({ isChecked: true, text: 'Buy a raccoon' });
+    await wait();
+    expect($('.my-checkbox').checked).toBe(true);
+    expect($('.text').textContent).toBe('Buy a raccoon');
+    // the first argument is the item, not a node
+    expect(items).toEqual([app[0]]);
+    expect(items[0]).toBeInstanceOf(MyModel);
+  });
+
+  it('DOC-6 track-by.md: the object with _id 1 is reused as BarNew, _id 3 is new', () => {
+    class MyArray extends Matreshka.Array {
+      get trackBy() {
+        return '_id';
+      }
+    }
+    const arr = new MyArray();
+    arr.recreate([
+      { _id: 0, name: 'Foo' },
+      { _id: 1, name: 'Bar' },
+      { _id: 2, name: 'Baz' }
+    ]);
+    const before = Array.from(arr);
+    arr.recreate([
+      { _id: 1, name: 'BarNew' },
+      { _id: 3, name: 'Qux' },
+      { _id: 2, name: 'BazNew' }
+    ]);
+    const byId = (id) => arr.find((item) => item._id === id);
+    expect(byId(1)).toBe(before[1]);
+    expect(byId(1).name).toBe('BarNew');
+    expect(byId(2)).toBe(before[2]);
+    expect(byId(2).name).toBe('BazNew');
+    expect(before).not.toContain(byId(3));
+    expect(Array.from(arr)).not.toContain(before[0]);
+    expect(arr.map((item) => item._id).toJSON()).toEqual([1, 3, 2]);
+  });
+
+  it('DOC-7 progress.md and style.md: the selectors name the bound node', async () => {
+    document.body.innerHTML = '<progress class="my-progress" max="100"></progress><div class="my-element"></div>';
+    const object = new Matreshka();
+    object.bindNode('myKey', '.my-progress', Matreshka.binders.progress());
+    object.bindNode('myStyle', '.my-element', Matreshka.binders.style('backgroundColor'));
+    object.myKey = 42;
+    object.myStyle = 'red';
+    await wait();
+    expect($('.my-progress').value).toBe(42);
+    // background-color of .my-element is red now
+    expect($('.my-element').style.backgroundColor).toBe('red');
+  });
+
+  it('DOC-8 types/matreshka.md: the sample calls calc on the instance it creates', () => {
+    const matreshka = new Matreshka();
+    matreshka.b = 1;
+    expect(matreshka.calc('a', 'b')).toBe(matreshka);
+    expect(matreshka.a).toBe(1);
+  });
+
+  it('DOC-9 to-json.md: a nested Matreshka.Array', () => {
+    const matreshkaArray = new Matreshka.Array(1, 2, new Matreshka.Array(3, 4));
+    // returns [1, 2, [3, 4]]
+    expect(matreshkaArray.toJSON()).toEqual([1, 2, [3, 4]]);
+    // returns [1, 2, MatreshkaArray]
+    expect(matreshkaArray.toJSON(false)[2].isMatreshkaArray).toBe(true);
+  });
+});

From 1728e0e48af7336bf2f92575a058e8526c4a0a30 Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:35:36 +0400
Subject: [PATCH 6/7] test: legacy scenario waits through timers

---
 test/legacy/scenario.js | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/test/legacy/scenario.js b/test/legacy/scenario.js
index cb6f115c..810610d2 100644
--- a/test/legacy/scenario.js
+++ b/test/legacy/scenario.js
@@ -14,15 +14,21 @@
   };
   // the case that runs now; an error in a later step fails it
   var current;
+  // hops through timers before the wait, so a debounced step that schedules the next one is done on a busy machine too
   var later = function (fn) {
     var owner = current;
-    setTimeout(function () {
-      try {
-        fn();
-      } catch (error) {
-        owner.finish(error);
-      }
-    }, 20);
+    var hops = 5;
+    var hop = function () {
+      if (hops--) return setTimeout(hop, 0);
+      setTimeout(function () {
+        try {
+          fn();
+        } catch (error) {
+          owner.finish(error);
+        }
+      }, 20);
+    };
+    hop();
   };
   var root = document.getElementById('legacy-root');
   var html = function (markup) {

From a8cec1101d76662c8a1b1d6f66d8c06684fc0672 Mon Sep 17 00:00:00 2001
From: Andrey Gubanov <andrii@gubanov.eu>
Date: Tue, 20 Oct 2026 15:38:18 +0400
Subject: [PATCH 7/7] test: strip comments until stable

---
 docs/test/code-parity.test.js | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/docs/test/code-parity.test.js b/docs/test/code-parity.test.js
index 172dfba0..89d6819d 100644
--- a/docs/test/code-parity.test.js
+++ b/docs/test/code-parity.test.js
@@ -1,13 +1,21 @@
 import { describe, expect, it } from 'vitest';
 import { pages } from './pages';
 
+// Repeats a replace until nothing changes, so a removal can't leave a new match behind.
+const replaceAll = (text, pattern, replacement) => {
+  let previous;
+  do {
+    previous = text;
+    text = text.replace(pattern, replacement);
+  } while (text !== previous);
+  return text;
+};
+
 // Code blocks of a page, comments dropped, each line trimmed with spaces collapsed, blank lines dropped.
 const codeBlocks = (md) =>
   [...md.matchAll(/^(`{3,})(\S*)[^\n]*\n([\s\S]*?)^\1[ \t]*$/gm)].map(([, , lang, code]) => ({
     lang,
-    lines: code
-      .replace(/<!--[\s\S]*?-->/g, '')
-      .replace(/\/\*[\s\S]*?\*\//g, '')
+    lines: replaceAll(replaceAll(code, /<!--[\s\S]*?-->/g, ''), /\/\*[\s\S]*?\*\//g, '')
       .replace(/(^|[\s;{}(),])\/\/.*$/gm, '$1')
       .split('\n')
       .map((line) => line.trim().replace(/[ \t]+/g, ' '))