fix: resolve all non-pointer browser test failures (32 → 13)

- Fix BEMHTML shim: only add i-bem class when js:true is explicit,
  matching real BEMHTML behavior (fixes delegated event handler
  ordering and block init issues)
- Fix entity storage pollution: use unique block names in spec files
  (collection-block, obs-dom-block) to prevent cross-spec conflicts
  when all specs run on one page
- Fix events.vanilla.js: use .call() instead of .apply(arguments)
  to pass correct (e, data) args to event handlers
- Fix modules-shim: eager resolution, incremental re-resolve,
  correct events__observable mapping
- Update MAX_ALLOWED_FAILURES to 13 (pointer polyfill tests only)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: veged

common.blocks/events/__observable/_type/events__observable_type_bem-dom.spec.js

@@ -18,8 +18,8 @@ describe('events__observable_type_bem-dom', function() {
         spy2 = sinon.spy();
         spy3 = sinon.spy();
         block = bemDom.init(BEMHTML.apply({
-            block : 'block'
-        })).appendTo('body').bem(bemDom.declBlock('block'));
+            block : 'obs-dom-block'
+        })).appendTo('body').bem(bemDom.declBlock('obs-dom-block'));
     });
 
     afterEach(function() {

common.blocks/events/events.vanilla.js

@@ -216,7 +216,7 @@ const Emitter = inherit(/** @lends Emitter.prototype */{
                         }
 
                         e.data = item.data
-                        const res = item.fn.apply(item.ctx || this, arguments)
+                        const res = item.fn.call(item.ctx || this, e, data)
                         if(res === false) {
                             e.preventDefault()
                             e.stopPropagation()

common.blocks/i-bem-dom/i-bem-dom.js

@@ -746,7 +746,7 @@ const BemDomEntity = inherit(/** @lends BemDomEntity.prototype */{
 
     /** @override */
     _processInit : function(heedInit) {
-        if(this.onInit && this._inited == heedInit) {  
+        if(this.onInit && this._inited == heedInit) {
             this.__base(heedInit)
 
             this.onInit()

common.blocks/i-bem/__collection/i-bem__collection.spec.js

@@ -13,7 +13,7 @@ modules.define('spec', [
 var expect = chai.expect;
 
 describe('BEM collections', function() {
-    var Block = bem.declBlock('block');
+    var Block = bem.declBlock('collection-block');
 
     describe('constructor', function() {
         it('should create collection of unique entities', function() {

test/browser.spec.js

@@ -1,16 +1,19 @@
 import { test, expect } from '@playwright/test';
 
-// Known failures that are expected and acceptable:
-// - 11 pointer event polyfill tests (modern browsers have native Pointer Events)
-// - 2 pointerpressrelease timeout tests (done() not called — polyfill not active)
-// - ~19 edge cases in BEMHTML/modules shim or jQuery 4.0 compatibility
-const MAX_ALLOWED_FAILURES = 35;
+// Known failures: 13 pointer event polyfill tests — modern browsers have native
+// Pointer Events, so the polyfill doesn't activate and its tests fail.
+const MAX_ALLOWED_FAILURES = 13;
 
 test('bem-core browser spec tests', async ({ page }) => {
     const pageErrors = [];
     page.on('pageerror', err => {
         pageErrors.push(`[pageerror] ${err.message}`);
     });
+    page.on('console', msg => {
+        if (msg.type() === 'warn' || msg.type() === 'error') {
+            console.log(`[browser:${msg.type()}] ${msg.text()}`);
+        }
+    });
 
     await page.goto('/test/browser/index.html');
 

test/browser/bemhtml-shim.js

@@ -60,10 +60,10 @@ const BEMHTML = {
                     else if (v) classes.push(`${block}_${m}_${v}`);
                 }
             }
-            if (js !== false) {
+            if (js) {
                 needBemClass = true;
                 dataBem = dataBem || {};
-                dataBem[block] = js && typeof js === 'object' ? js : {};
+                dataBem[block] = typeof js === 'object' ? js : {};
             }
         } else if (block && elem) {
             // Element
@@ -76,10 +76,10 @@ const BEMHTML = {
                 }
             }
             // Elements get data-bem and i-bem if js is explicitly provided
-            if (js && typeof js === 'object') {
+            if (js) {
                 needBemClass = true;
                 dataBem = dataBem || {};
-                dataBem[elemName] = js;
+                dataBem[elemName] = typeof js === 'object' ? js : {};
             }
         }
 
@@ -88,7 +88,7 @@ const BEMHTML = {
             const mixes = Array.isArray(mix) ? mix : [mix];
             for (const m of mixes) {
                 if (!m) continue;
-                const mixBlock = m.block || ctx;
+                const mixBlock = m.block || block || ctx;
                 if (!mixBlock) continue;
                 const mixClass = m.elem
                     ? `${mixBlock}__${m.elem}`
@@ -112,10 +112,10 @@ const BEMHTML = {
                     dataBem = dataBem || {};
                     dataBem[mixBlock] =
                         m.js && typeof m.js === 'object' ? m.js : {};
-                } else if (m.elem && m.js && typeof m.js === 'object') {
+                } else if (m.elem && m.js) {
                     needBemClass = true;
                     dataBem = dataBem || {};
-                    dataBem[mixClass] = m.js;
+                    dataBem[mixClass] = typeof m.js === 'object' ? m.js : {};
                 }
             }
         }

test/browser/entry.js

@@ -83,7 +83,7 @@ window.modules = createModulesShim({
     'next-tick': nextTick,
     'strings__escape': stringsEscape,
     events,
-    'events__observable': eventsObservable,
+    'events__observable': eventsObservableBemDom,
     'events__observable_type_bem-dom': eventsObservableBemDom,
     dom,
     cookie,

test/browser/modules-shim.js

@@ -5,9 +5,12 @@
  *   modules.define(name, deps, factory)   — normal definition
  *   modules.define(name, factory)          — redefinition (factory receives prev value as 2nd arg)
  *   modules.require(deps, factory)         — resolve deps synchronously, call factory
+ *
+ * Eagerly resolves first definitions when all deps are available (ym behavior).
+ * Supports incremental resolution: previously resolved entries are skipped on re-resolve.
  */
 export function createModulesShim(preRegistered) {
-    // name → [{deps, factory, isRedef}]
+    // name → [{deps, factory, isRedef, resolved}]
     const registry = new Map();
     // name → resolved value (cache)
     const resolved = new Map();
@@ -17,10 +20,13 @@ export function createModulesShim(preRegistered) {
     }
 
     function resolve(name) {
-        if (resolved.has(name)) return resolved.get(name);
-
         const entries = registry.get(name);
+        const hasUnresolved = entries && entries.some(e => !e.resolved);
+
+        if (resolved.has(name) && !hasUnresolved) return resolved.get(name);
+
         if (!entries || !entries.length) {
+            if (resolved.has(name)) return resolved.get(name);
             throw new Error(
                 `Module "${name}" is not defined.\nKnown: ${[
                     ...resolved.keys(),
@@ -29,16 +35,19 @@ export function createModulesShim(preRegistered) {
             );
         }
 
-        let value;
+        let value = resolved.get(name);
         let runCount = 0;
-        for (const { deps, factory, isRedef } of entries) {
+        for (const entry of entries) {
+            if (entry.resolved) continue;
             try {
-                const depVals = deps.map(d => resolve(d));
-                if (isRedef) {
-                    factory(v => { value = v; }, value, ...depVals);
+                const depVals = entry.deps.map(d => resolve(d));
+                const thisCtx = { name };
+                if (entry.isRedef) {
+                    entry.factory.call(thisCtx, v => { value = v; }, value, ...depVals);
                 } else {
-                    factory(v => { value = v; }, ...depVals);
+                    entry.factory.call(thisCtx, v => { value = v; }, ...depVals);
                 }
+                entry.resolved = true;
                 runCount++;
             } catch (err) {
                 // Log but continue — one failing spec factory must not block others
@@ -56,11 +65,14 @@ export function createModulesShim(preRegistered) {
             const deps = isRedef ? [] : depsOrFactory;
             const factory = isRedef ? depsOrFactory : factoryArg;
 
-            if (!registry.has(name)) registry.set(name, []);
-            registry.get(name).push({ deps, factory, isRedef });
+            const isFirst = !registry.has(name);
+            if (isFirst) registry.set(name, []);
+            registry.get(name).push({ deps, factory, isRedef, resolved: false });
 
-            // Clear cache if re-defining after resolution
-            resolved.delete(name);
+            // Eagerly resolve first non-redef definitions when all deps are available
+            if (isFirst && !isRedef && deps.every(d => resolved.has(d))) {
+                try { resolve(name); } catch (e) { /* ignore — will be resolved on require */ }
+            }
         },
 
         require(deps, factory) {