@lmjs/core 2.0.0 → 2.1.0

package/src/dom-shim.js

@@ -128,11 +128,33 @@
         return this;
     };
     $.fn.get = function (i) { return i === undefined ? toArray(this) : this[i]; };
+    // 2026-09-17, found alongside .find()/.is() (same real bug's radio-
+    // group branch in checkFormInputs()) — excludes elements matching a
+    // raw DOM node, an array of nodes, or a $()-wrapped set; jQuery also
+    // supports a selector string here, not needed by anything in this
+    // codebase's actual usage (grepped), so not implemented.
+    $.fn.not = function (exclude) {
+        var excludeArr = exclude instanceof $ ? toArray(exclude) : (Array.isArray(exclude) ? exclude : [exclude]);
+        var out = [];
+        this.each(function () { if (excludeArr.indexOf(this) === -1) out.push(this); });
+        return $(out);
+    };
 
     $.fn.attr = function (name, value) {
         if (value === undefined) return this[0] ? this[0].getAttribute(name) : undefined;
         return this.each(function () { this.setAttribute(name, value); });
     };
+    // 2026-09-17, found in the same real-page click test as .find()/.is()/
+    // .not() above — real jQuery distinguishes .prop() (a direct DOM
+    // property, e.g. .checked/.disabled/.scrollHeight) from .attr() (the
+    // HTML attribute string); the two diverge for exactly the boolean
+    // properties this codebase's real usage needs (checkFormInputs()'s
+    // "disabled", the vendored search-widget's "disabled", scroll
+    // measurements) — grepped actual call sites, not guessed.
+    $.fn.prop = function (name, value) {
+        if (value === undefined) return this[0] ? this[0][name] : undefined;
+        return this.each(function () { this[name] = value; });
+    };
     $.fn.removeAttr = function (name) {
         return this.each(function () { this.removeAttribute(name); });
     };
@@ -188,6 +210,15 @@
         }
         return this.each(function () { this.innerHTML = value; });
     };
+    // 2026-09-17, found alongside .find()/.is()/.not()/.prop() above —
+    // checkFormInputs()'s "data-into" error-message branch calls
+    // into.text(...). Not hit by the specific real page that surfaced
+    // the others (this codebase's checkbox demo has no data-into), added
+    // proactively rather than waiting for a second real crash to find it.
+    $.fn.text = function (value) {
+        if (value === undefined) return this[0] ? this[0].textContent : '';
+        return this.each(function () { this.textContent = value; });
+    };
     $.fn.css = function (name, value) {
         if (typeof name === 'object') {
             return this.each(function () {
@@ -306,6 +337,45 @@
     $.fn.parent = function () { return $(this[0] ? this[0].parentElement : null); };
     $.fn.next = function () { return $(this[0] ? this[0].nextElementSibling : null); };
     $.fn.closest = function (sel) { return $(this[0] ? this[0].closest(sel) : null); };
+    // 2026-09-17, real bug found and fixed: never implemented at all —
+    // vendor/reconnecting-websocket.js's ported V1 form-validation code
+    // (checkFormInputs()) calls f.find(...) on the result of .closest(
+    // "form"), and .closest() legitimately returns an empty $() when
+    // there's no enclosing form (a completely normal case — a single
+    // checkbox/input outside a <form>). With .find() missing, that threw
+    // "f.find is not a function" the moment ANY input/textarea/select
+    // fired a "change" event anywhere on the page, form or no form —
+    // found clicking a plain checkbox on lumenjs.com's own real V2
+    // homepage. Real jQuery .find() semantics: search descendants of
+    // each matched element, union the results (safe/empty on an empty
+    // set, exactly what's needed here).
+    $.fn.find = function (sel) {
+        var out = [];
+        this.each(function () {
+            var found = this.querySelectorAll(sel);
+            for (var i = 0; i < found.length; i++) if (out.indexOf(found[i]) === -1) out.push(found[i]);
+        });
+        return $(out);
+    };
+    // 2026-09-17, found alongside .find() (same crash, next line of the
+    // same real bug): checkFormInputs() also calls el.is(":checkbox")/
+    // ":radio"/":checked" — real CSS pseudo-classes for the former two
+    // don't exist (native .matches(":checkbox") throws a SyntaxError,
+    // it's a jQuery-only pseudo-selector), so a short, explicit table for
+    // the handful actually used across the vendored code (grepped, not
+    // guessed) plus a native .matches() fallback for everything else
+    // (tag names, real attribute selectors like "[dp0]") — safely false
+    // rather than throwing if a selector native matches() can't parse.
+    var JQUERY_PSEUDOS = {
+        ':checkbox': function (el) { return el.tagName === 'INPUT' && el.type === 'checkbox'; },
+        ':radio': function (el) { return el.tagName === 'INPUT' && el.type === 'radio'; },
+        ':checked': function (el) { return !!el.checked; },
+    };
+    $.fn.is = function (sel) {
+        if (!this[0]) return false;
+        if (JQUERY_PSEUDOS[sel]) return JQUERY_PSEUDOS[sel](this[0]);
+        try { return this[0].matches(sel); } catch (e) { return false; }
+    };
     $.fn.ready = function (fn) {
         if (document.readyState !== 'loading') fn($);
         else document.addEventListener('DOMContentLoaded', function () { fn($); });
@@ -468,6 +538,103 @@
         return this;
     };
 
+    // 2026-09-18, real gap found testing a real migrated V1 project end-to-
+    // end: `st()` (vendor/reconnecting-websocket.js's own real, shipped
+    // scroll-to helper — not project code, framework code) does
+    // `$("html,body").stop().animate({scrollTop: x}, {duration: 400})` —
+    // a very common pattern across real V1 pages (called at the top of
+    // most real view scripts for smooth-scroll navigation). Neither
+    // method existed in the shim at all, throwing "not a function" and
+    // aborting the rest of that script on every real page that called it.
+    // `scrollTop`/`scrollLeft` are DOM properties, not CSS ones — handled
+    // as a special case, matching real jQuery's own animate() behavior;
+    // any other property is treated as a numeric CSS property (adding
+    // "px" unless it's already a bare number-only string/value, matching
+    // jQuery's own unit-inference for a plain number).
+    var _animTimers = new WeakMap();
+    function _animGetScroll(el, prop) {
+        if (el === window) return prop === 'scrollLeft' ? window.pageXOffset : window.pageYOffset;
+        return el[prop];
+    }
+    function _animSetScroll(el, prop, val) {
+        if (el === window) {
+            if (prop === 'scrollLeft') window.scrollTo(val, window.pageYOffset);
+            else window.scrollTo(window.pageXOffset, val);
+        } else {
+            el[prop] = val;
+        }
+    }
+    // Real jQuery's own cssNumber list — these CSS properties take a bare
+    // unitless number, not "Npx" (opacity: "0.5px" is simply invalid and
+    // silently ignored by the browser, which is exactly what broke the
+    // very first real-content test of this: an opacity fade never moved).
+    var _cssNumberProps = { opacity: 1, zIndex: 1, zoom: 1, fontWeight: 1, lineHeight: 1, columnCount: 1, flexGrow: 1, flexShrink: 1, order: 1, widows: 1, orphans: 1 };
+    function _animSetStyle(el, prop, val) {
+        el.style[prop] = _cssNumberProps[prop] ? val : (val + 'px');
+    }
+    $.fn.animate = function (props, options) {
+        var opts = typeof options === 'number' ? { duration: options } : (options || {});
+        var duration = opts.duration == null ? 400 : opts.duration;
+        this.each(function () {
+            var el = this;
+            var isWindowScroll = (el === document.documentElement || el === document.body);
+            var target = isWindowScroll ? window : el;
+            var start = {};
+            var isScrollProp = {};
+            for (var prop in props) {
+                if (!Object.prototype.hasOwnProperty.call(props, prop)) continue;
+                isScrollProp[prop] = (prop === 'scrollTop' || prop === 'scrollLeft');
+                if (isScrollProp[prop]) {
+                    start[prop] = _animGetScroll(isWindowScroll ? window : el, prop);
+                } else {
+                    start[prop] = parseFloat(getComputedStyle(el)[prop]) || 0;
+                }
+            }
+            var existing = _animTimers.get(el);
+            if (existing) cancelAnimationFrame(existing);
+            if (duration === 0) {
+                for (var p in props) {
+                    var v = parseFloat(props[p]);
+                    if (isScrollProp[p]) _animSetScroll(isWindowScroll ? window : el, p, v);
+                    else _animSetStyle(el, p, v);
+                }
+                if (opts.complete) opts.complete.call(el);
+                return;
+            }
+            var startTime = null;
+            function step(ts) {
+                if (startTime === null) startTime = ts;
+                var elapsed = ts - startTime;
+                var t = Math.min(1, elapsed / duration);
+                for (var p in props) {
+                    if (!Object.prototype.hasOwnProperty.call(props, p)) continue;
+                    var end = parseFloat(props[p]);
+                    var val = start[p] + (end - start[p]) * t;
+                    if (isScrollProp[p]) _animSetScroll(isWindowScroll ? window : el, p, val);
+                    else _animSetStyle(el, p, val);
+                }
+                if (t < 1) {
+                    _animTimers.set(el, requestAnimationFrame(step));
+                } else {
+                    _animTimers.delete(el);
+                    if (opts.complete) opts.complete.call(el);
+                }
+            }
+            _animTimers.set(el, requestAnimationFrame(step));
+        });
+        return this;
+    };
+    $.fn.stop = function () {
+        this.each(function () {
+            var id = _animTimers.get(this);
+            if (id) {
+                cancelAnimationFrame(id);
+                _animTimers.delete(this);
+            }
+        });
+        return this;
+    };
+
     global.$ = $;
     global.jQuery = $;
 })(typeof window !== 'undefined' ? window : globalThis);

package/src/index-bootstrap.js

@@ -41,7 +41,13 @@ if (typeof _beaTn === 'undefined' || !_beaTn) {
                 console.log('Failed to load index.js: HTTP ' + _idxXhr.status);
             }
         } catch (e) {
-            console.log('Failed to load index.js: ', e);
+            // 2026-09-17: was console.log — a real exception partway through
+            // index.js (e.g. the _vt.Global.fns crash this session found and
+            // fixed) silently looked like nothing happened at all in dev
+            // mode, while the same bug was fatal in a real production
+            // build (index.js runs inline there, unguarded). A real error
+            // here should be as visible as reportLumenError()'s.
+            console.error('Failed to load index.js: ', e);
         }
     }
 }

package/src/lstnrs.js

@@ -496,9 +496,27 @@ $("body").on("modal-open", "[\\@modal-open]", function (ev, modal) {
 function evalEvAttr(_v, ev, el, n, arg1, arg2, arg3) {
   let _fn = _v.split("(")[0];
   try {
-    if (typeof window[_v] === "function") {
+    // 2026-09-17: prefer the triggering element's OWN rendering instance's
+    // function registry (._ownerRe.view.fns, set up by walk.js's
+    // _fnRegisterStatement() + _re.js's createEl()/renderHST()) over the
+    // plain `window[_fn]` lookup below — real bug found and fixed: every
+    // mounted instance of the same subview declaring a same-named handler
+    // (e.g. multiple `<div view="widgets/card">` each with their own
+    // `function bump(){}`) used to collide on one global, since a plain
+    // <script> tag's top-level function declarations all write to the
+    // same `window` object — window.bump silently became whichever
+    // instance's script last ran, so every instance's @click fired THAT
+    // one instance's handler regardless of which was actually clicked.
+    // Only applies to the plain-name form (`_v === _fn`, no `(...)`) —
+    // a parameterized attribute like `@click="fn(x)"` already falls
+    // through to the eval() branch below unchanged, exactly as before.
+    let _rawEl = el[0];
+    let _ownerFns = _rawEl && _rawEl._ownerRe && _rawEl._ownerRe.view && _rawEl._ownerRe.view.fns;
+    let _ownFn = (_v === _fn && _ownerFns && typeof _ownerFns[_fn] === "function") ? _ownerFns[_fn] : null;
+    if (_ownFn || typeof window[_v] === "function") {
       ev["cType"] = n;
-      var _data = arg3 ? window[_fn](ev, el, arg1, arg2, arg3) : (arg2 ? window[_fn](ev, el, arg1, arg2) : (arg1 ? window[_fn](ev, el, arg1) : window[_fn](ev, el)));
+      let _handler = _ownFn || window[_fn];
+      var _data = arg3 ? _handler(ev, el, arg1, arg2, arg3) : (arg2 ? _handler(ev, el, arg1, arg2) : (arg1 ? _handler(ev, el, arg1) : _handler(ev, el)));
       return _data;
     } else {
       let _eva = eval(_v);

package/src/walk.js

@@ -278,6 +278,28 @@ function getL1Vs(AST, view, vazzz) {
 }
 
 function getWatcher(AST, view, vazzz, targetKey = "View") {
+    // 2026-09-17, real bug found and fixed: changeReactiveVarsOccurences()/
+    // transformTopLevelDeclarations() mutate the AST IN PLACE (they
+    // replace nodes via `parent[prop] = replacement`, not by building a
+    // new tree) — harmless as long as a given AST object is only ever
+    // rewritten once, which used to always be true. Per-instance subview
+    // scoping changed that: renderHST() (_re.js) is called once per
+    // subview MOUNT, but all mounts of the same .view file share the
+    // exact same parsed `nd._jst` object (parsed once, cached, reused) —
+    // so the first instance's rewrite (into e.g. _vt.View.views[0].vars)
+    // permanently consumed the raw identifiers, and every subsequent
+    // instance's "rewrite" silently found nothing left to rewrite,
+    // regenerating instance 0's already-rewritten code unchanged. Found
+    // testing 3 real mounted instances of the same subview on lumenjs.com's
+    // own V2 homepage — only the first ever got its own correct scope.
+    // Cloning here (not at each call site) makes getWatcher() safe to
+    // call repeatedly against the same input AST, which is now a real
+    // requirement, not just good hygiene. ASTs are plain, JSON-safe data
+    // (no functions/circular refs), so JSON round-tripping is a correct,
+    // dependency-free deep clone — walk.js has no access to the vendored
+    // recursive clone() helper (a different, browser-only bundle file).
+    AST = JSON.parse(JSON.stringify(AST));
+
     let Vars = getL1Vs(AST, view, vazzz);
     AST = Vars['AST'];
     let varz = Vars['varz'];
@@ -313,11 +335,46 @@ function validateBeforeRewrite(AST, view) {
     }
 }
 
+// 2026-09-17: `targetKey` used to only ever be a plain string ("View" or
+// "Global"), producing a fixed 2-level root (`_vt.View`/`_vt.Global`). Real
+// per-instance subview scoping (`_vt.View.views[i].vars`, and its nested
+// form `_vt.View.views[0].views[2].vars` for a subview hosting a subview)
+// needs a *deeper* chain than a single Identifier can express. Accepts
+// either form now: a bare string is treated as a one-element path (100%
+// unchanged output for every existing caller — "View"/"Global" still build
+// exactly `_vt.View`/`_vt.Global`); an array of segments builds the real
+// chain, a string segment as a non-computed Identifier access, a number
+// segment as a computed numeric-literal access (`.views[3]`).
+function buildTargetRootExpr(targetKey) {
+    const segments = Array.isArray(targetKey) ? targetKey : [targetKey];
+    let expr = { type: "Identifier", name: "_vt" };
+    for (const seg of segments) {
+        if (typeof seg === "number") {
+            expr = {
+                type: "MemberExpression",
+                object: expr,
+                property: { type: "Literal", value: seg, raw: String(seg) },
+                computed: true
+            };
+        } else {
+            expr = {
+                type: "MemberExpression",
+                object: expr,
+                property: { type: "Identifier", name: seg },
+                computed: false
+            };
+        }
+    }
+    return expr;
+}
+
 // The kept reactive-variable rewrite: turns a reference to a reactive
 // variable into `_vt.View.vars["<name>"]`, matching `_re.js`'s Proxy target.
 // `targetKey` (2026-09-14): which root of `_vt` to rewrite into — "View"
 // (default, unchanged) for .view <script> blocks, "Global" for index.js's
 // top-level vars, which need to outlive a single view (see _re.js's _vt.Global).
+// Can also be a path array (see buildTargetRootExpr above) for a subview
+// instance's own scope.
 function changeReactiveVarsOccurences(AST, reactiveVariables, targetKey = "View") {
     const reactive = new Set(reactiveVariables || []);
 
@@ -611,17 +668,12 @@ function changeReactiveVarsOccurences(AST, reactiveVariables, targetKey = "View"
                     parent.shorthand = false;
                 }
 
-                // Build computed member expression: _vt.View.vars["<name>"]
+                // Build computed member expression: _vt.<targetKey>.vars["<name>"]
                 const replacement = {
                     type: "MemberExpression",
                     object: {
                         type: "MemberExpression",
-                        object: {
-                            type: "MemberExpression",
-                            object: { type: "Identifier", name: "_vt" },
-                            property: { type: "Identifier", name: targetKey },
-                            computed: false
-                        },
+                        object: buildTargetRootExpr(targetKey),
                         property: { type: "Identifier", name: "vars" },
                         computed: false
                     },
@@ -684,12 +736,7 @@ function _reactiveAssignStatement(name, init, targetKey = "View") {
                 object: {
                     type: "MemberExpression",
                     computed: false,
-                    object: {
-                        type: "MemberExpression",
-                        computed: false,
-                        object: { type: "Identifier", name: "_vt" },
-                        property: { type: "Identifier", name: targetKey }
-                    },
+                    object: buildTargetRootExpr(targetKey),
                     property: { type: "Identifier", name: "vars" }
                 },
                 property: { type: "Literal", value: name }
@@ -699,6 +746,41 @@ function _reactiveAssignStatement(name, init, targetKey = "View") {
     };
 }
 
+// 2026-09-17: registers a top-level function declaration onto this
+// render's own scope (`_vt.<targetKey>.fns["name"] = name`) — ADDITIVE,
+// not a replacement: the function declaration itself is left completely
+// untouched right above this (still a real `window.name` too, the
+// existing, deliberate "functions stay real globals so onclick='fn()'
+// keeps working" design — see compileProjectScript's matching comment).
+// Needed once multiple instances of the same subview can be mounted at
+// once (see _re.js's per-instance scoping work) — every instance
+// declaring a same-named handler collided on the one global function
+// (window.bump became whichever instance's script ran last), so every
+// instance's @click ended up calling THAT one instance's handler
+// regardless of which was actually clicked. lstnrs.js's evalEvAttr()
+// checks this per-instance copy first, before falling back to window.
+function _fnRegisterStatement(name, targetKey) {
+    return {
+        type: "ExpressionStatement",
+        expression: {
+            type: "AssignmentExpression",
+            operator: "=",
+            left: {
+                type: "MemberExpression",
+                computed: true,
+                object: {
+                    type: "MemberExpression",
+                    computed: false,
+                    object: buildTargetRootExpr(targetKey),
+                    property: { type: "Identifier", name: "fns" }
+                },
+                property: { type: "Literal", value: name }
+            },
+            right: { type: "Identifier", name: name }
+        }
+    };
+}
+
 // Handles any number of declarators in a single top-level statement, not just
 // one. `var x = 1, y = 2;` with only `x` reactive becomes two statements:
 // `_vt.View.vars["x"] = 1;` followed by a real `var y = 2;` for the rest —
@@ -709,6 +791,12 @@ function transformTopLevelDeclarations(AST, reactiveVariables, targetKey = "View
     const newBody = [];
 
     for (const stmt of AST.body) {
+        if (stmt.type === "FunctionDeclaration" && stmt.id) {
+            newBody.push(stmt);
+            newBody.push(_fnRegisterStatement(stmt.id.name, targetKey));
+            continue;
+        }
+
         if (stmt.type !== "VariableDeclaration") {
             newBody.push(stmt);
             continue;

package/vendor/reconnecting-websocket.js

@@ -247,6 +247,31 @@ var _ups = [];
         if (o.Additional) {
             bea([o.Additional], "ready", function () { });
         }
+        // 2026-09-18, real bug found and fixed: Reactor({init, tick, auth})
+        // is documented (lumenjs-spec.md §3, llms.md §3) and real V1 projects
+        // depend on it (app-wide bootstrap work in init() — auth/session
+        // setup, an SDK instance like `rx = new RX(...)`/`bea = new BEA(...)`,
+        // globals defaults; periodic work in tick(), e.g. re-highlighting
+        // code blocks after every render) — but nothing in this whole
+        // runtime ever read o.init/o.tick/o.auth at all. A real, unrelated-
+        // looking function (setAppFuncs(), earlier in this same file) does
+        // check appSettings.init — but is itself never called from
+        // anywhere in the shipped runtime, dead code calling more dead
+        // code. Confirmed via a real migrated V1 project end-to-end:
+        // `init()`-set globals (`globals.Settings`, an `rx`/`bea` SDK
+        // instance) were silently never set, with no error at all — every
+        // reference to them elsewhere threw "not defined" instead, easy to
+        // misdiagnose as an unrelated data/scoping bug (which is exactly
+        // what this took real, extensive tracing to rule out).
+        // init(): synchronous, called once, right here — Reactor(o) itself
+        // is always the first thing a real index.js does, before whatever
+        // triggers the first render (the ready-handler retry guard
+        // elsewhere in this file already waits on appSettings.Base, set
+        // just above, so no render can start before this function returns).
+        if (o.init && typeof o.init === "function") o.init();
+        // tick(): "after every re-render, anywhere" (documented) — hooked
+        // into _lm.prototype.renderAll in _re.js instead of duplicated
+        // here; see that file's own comment for why there, not here.
     };
 });