gina 0.6.4 → 0.6.5

package/framework/{v0.6.4 → v0.6.5}/core/plugins/lib/validator/src/main.js

@@ -756,6 +756,23 @@ function ValidatorPlugin(rules, data, formId, culture) {
 
     }
 
+    /**
+     * #B319 — one-shot exemption raised while the framework moves focus to the
+     * first invalid field to DELIVER a refused submit's answer (the #B246/#B308
+     * display-only reveal, and the `validate.<id>` failure branch). `.focus()`
+     * dispatches `focusin` synchronously, so without this flag that dispatch
+     * re-enters the live-check listener whose `refreshWarning` call sees the
+     * field is by then the active element and hides the very message the answer
+     * just rendered (#B312: the message IS the answer). The focusin arm skips
+     * the downgrade while the flag is up; both focus sites clear it on every
+     * exit, so the user's next interaction — typing, refocusing — re-engages
+     * the deliberate mid-typing suppression untouched.
+     *
+     * @private
+     * @type {boolean}
+     */
+    var isAnswerFocusInProgress = false;
+
     var refreshWarning = function($el) {
         var formId = $el.form.id || $el.form.getAttribute('id');
         var elName = $el.name || $el.form.getAttribute('name');
@@ -2143,6 +2160,15 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     if ($submitTrigger) {
                         // For A tag: aria-disabled=true
                         if ( /^A$/i.test($submitTrigger.tagName) ) {
+                            // #B312 — unconditional again: the live-check gate now marks
+                            // `data-gina-form-submit-gated` (its own channel, untouched
+                            // here), so the in-flight lock is aria-disabled's only
+                            // framework writer on this trigger and the #B309 verdict
+                            // replay — a conditional re-mark read from the form's
+                            // `_gateMarked` shadow (commit cf366c34a) — had nothing left
+                            // to replay and is retired. An authored aria mark set
+                            // mid-flight is still released here; that was equally true
+                            // of the replay.
                             $submitTrigger.removeAttribute('aria-disabled');
                         } else {
                             $submitTrigger.removeAttribute('disabled');
@@ -2221,9 +2247,17 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     if ($submitTrigger) {
                         // For A tag: aria-disabled=true
                         if ( /^A$/i.test($submitTrigger.tagName) ) {
-                            $submitTrigger.removeAttribute('aria-disabled', true);
+                            // #B312 — unconditional again, in step with the loadend
+                            // release above (the #B309 verdict replay is retired with
+                            // the shared attribute — the gate marks its own channel
+                            // now), and the stray 2nd argument fixed by #B309 stays
+                            // gone.
+                            // was:
+                            // $submitTrigger.removeAttribute('aria-disabled', true);
+                            $submitTrigger.removeAttribute('aria-disabled');
                         } else {
-                            $submitTrigger.removeAttribute('disabled', true);
+                            // was: $submitTrigger.removeAttribute('disabled', true);
+                            $submitTrigger.removeAttribute('disabled');
                         }
                     }
                     $form.target.removeAttribute('data-gina-form-loading');
@@ -2258,7 +2292,7 @@ function ValidatorPlugin(rules, data, formId, culture) {
                                 var url = window.URL.createObjectURL(blob);
                                 a.href = url;
                                 var contentDisposition = xhr.getResponseHeader("Content-Disposition");
-                                a.download = contentDisposition.match('\=(.*)')[0].substring(1);
+                                a.download = getFilenameFromContentDisposition(contentDisposition);
                                 //programatically click the link to trigger the download
                                 a.click();
 
@@ -5354,7 +5388,13 @@ function ValidatorPlugin(rules, data, formId, culture) {
                         }
                         // other inputs & textareas
                         else if ( /^focusin\./i.test(event.type) ) {
-                            if ( /\-error/.test($el.parentNode.className) ) {
+                            // #B319 — not on the answer focus: when a refused submit
+                            // moves focus to the first invalid field, the message it
+                            // just rendered must survive its own delivery.
+                            if (
+                                /\-error/.test($el.parentNode.className)
+                                && !isAnswerFocusInProgress
+                            ) {
                                 console.debug('#1 you just focusin ....'+$el.id, $el.value, instance.$forms[ $el.form.getAttribute('id') ].isValidating);
                                 refreshWarning($el);
                             }
@@ -7996,20 +8036,18 @@ function ValidatorPlugin(rules, data, formId, culture) {
                         _evt = 'reset.'+_evt
                     }
 
-                    // #B246 — a disabled submit trigger must not run the submit cycle.
-                    // `updateSubmitTriggerState()` marks an invalid form's trigger with
-                    // `aria-disabled="true"` and never with native `disabled`, precisely so
-                    // the click still reaches us. Nothing READ that marker, so the trigger
-                    // stayed fully operable: a click ran the collect -> validate ->
-                    // `validate.<id>` chain and only the `isValid()` gate stopped the send.
-                    // The trigger was inert in appearance ONLY, and that also contradicted
-                    // the `aria-disabled` contract it advertises to assistive tech (which
-                    // requires the author to suppress the action).
+                    // #B246 — a gated or disabled submit trigger must not run the submit
+                    // cycle. `updateSubmitTriggerState()` marks an invalid form's trigger
+                    // with `data-gina-form-submit-gated` + a class (#B312 — the
+                    // framework's own channel, no ARIA claim, precisely so the click
+                    // still reaches us and the vocabulary stays honest), and
+                    // `isTriggerDisabled` ALSO honours an AUTHORED aria/native disabled
+                    // mark and the anchor in-flight lock.
                     //
                     // Intercept HERE — before the `submit.<id>` dispatch below — so
                     // `bindSubmitEl`'s handler never runs, `isSubmitting` is never latched
                     // and no send path is reachable. The click is still answered with a
-                    // display-only reveal, so the user learns WHY the trigger is disabled
+                    // display-only reveal, so the user learns WHY the trigger is refused
                     // (which is what the operable-trigger design was bought for).
                     // Checked on the CLICKED element, not `$formInstance.submitTrigger`:
                     // a form may carry several submit buttons and only one registers.
@@ -8035,6 +8073,24 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     }
 
                     if (gina.events[_evt]) {
+                        // #B294 — submit binding is TWO-STAGE and only the first stage is
+                        // delegated. The native click proxy lives on the FORM (:8090) and
+                        // survives any re-render; the listener that does the work is
+                        // attached to the trigger NODE by `bindSubmitEl` (:8231). Because
+                        // `gina.events` is a name -> id-STRING registry, the `submit.<id>`
+                        // key outlives the node, so after an AJAX/popin re-render replaces
+                        // the trigger this gate still passes: `cancelEvent` below suppresses
+                        // the native submit and `triggerEvent` fires at a node that has no
+                        // listener. The form does not even fall back to a normal submit, and
+                        // nothing self-heals — `bindForm` latches `binded` (:8580) and is
+                        // never re-entered on DOM replacement — so the trigger was
+                        // permanently and silently dead.
+                        // Re-bind the live node when its marker is absent. A clone cannot
+                        // inherit the expando, so this fires exactly once per replacement
+                        // and is a no-op on the normal path.
+                        if ( $el && $el.__ginaSubmitBoundFor !== _evt ) {
+                            bindSubmitEl(_evt, $el);
+                        }
                         cancelEvent(event);
 
                         triggerEvent(gina, $el, _evt, event.detail);
@@ -8191,25 +8247,33 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     var _a11yErrs = result['fields'] || result['error'];
                     if ( _a11yErrs ) {
                         var $a11yForm = event['target'];
-                        for (var _ai = 0, _aLen = $a11yForm.length; _ai < _aLen; ++_ai) {
-                            var _aField = $a11yForm[_ai];
-                            var _aName  = _aField.getAttribute('name');
-                            if (
-                                _aName
-                                && typeof(_a11yErrs[_aName]) != 'undefined'
-                                && ( typeof(_a11yErrs[_aName].count) != 'function' || _a11yErrs[_aName].count() > 0 )
-                                && _aField.type != 'hidden'
-                                && typeof(_aField.focus) == 'function'
-                            ) {
-                                _aField.focus();
-                                // #A11Y5 (V8) — kept in step with focusFirstInvalidField:
-                                // only stop once focus actually moved, since focus() is a
-                                // no-op on an unfocusable host that still passes the
-                                // typeof-function gate above.
-                                if ( typeof(document) === 'undefined' || !document || document.activeElement === _aField ) {
-                                    break;
+                        // #B319 — same one-shot answer-focus exemption as
+                        // focusFirstInvalidField: this focus delivers the
+                        // answer, it is not the user editing the field.
+                        isAnswerFocusInProgress = true;
+                        try {
+                            for (var _ai = 0, _aLen = $a11yForm.length; _ai < _aLen; ++_ai) {
+                                var _aField = $a11yForm[_ai];
+                                var _aName  = _aField.getAttribute('name');
+                                if (
+                                    _aName
+                                    && typeof(_a11yErrs[_aName]) != 'undefined'
+                                    && ( typeof(_a11yErrs[_aName].count) != 'function' || _a11yErrs[_aName].count() > 0 )
+                                    && _aField.type != 'hidden'
+                                    && typeof(_aField.focus) == 'function'
+                                ) {
+                                    _aField.focus();
+                                    // #A11Y5 (V8) — kept in step with focusFirstInvalidField:
+                                    // only stop once focus actually moved, since focus() is a
+                                    // no-op on an unfocusable host that still passes the
+                                    // typeof-function gate above.
+                                    if ( typeof(document) === 'undefined' || !document || document.activeElement === _aField ) {
+                                        break;
+                                    }
                                 }
                             }
+                        } finally {
+                            isAnswerFocusInProgress = false;
                         }
                     }
                 }
@@ -8228,6 +8292,16 @@ function ValidatorPlugin(rules, data, formId, culture) {
                 evt = 'submit.'+ evt;
             }
             //console.debug('attaching submit event: `'+  evt +'` on `'+ $submit.id + '` element for form `'+ $submit.form.id +'`');
+            // #B294 — mark the node this listener is ACTUALLY attached to. Deliberately
+            // a JS expando and NOT a `data-*` attribute: `cloneNode(true)` copies
+            // attributes but not expandos (measured), so a re-rendered trigger arrives
+            // carrying every attribute yet WITHOUT this marker. That asymmetry is what
+            // makes it a reliable "is this the bound node?" test — and it is why the
+            // inherited `dataset.ginaFormSubmitTriggerFor` cannot serve the same purpose.
+            // Assigned after the `submit.` prefix is normalised above, so it holds the
+            // same string `clickProxyHandler` compares against. Read at the :8037
+            // dispatch gate.
+            $submit.__ginaSubmitBoundFor = evt;
             addListener(gina, $submit, evt, function(event) {
                 // start validation
                 cancelEvent(event);
@@ -8415,13 +8489,39 @@ function ValidatorPlugin(rules, data, formId, culture) {
                 , isBinded          = $form.binded
             ;
 
-            // check submit trigger status
-            var submitTrigger = new DOMParser()
-                .parseFromString($target.innerHTML, 'text/html')
-                .getElementById($formInstance.submitTrigger);
-            // prevent submit if disabled
-            if ( submitTrigger && submitTrigger.disabled) {
-                cancelEvent(e);
+            // #B308 — the disabled gate for USER GESTURES, with #B246's own predicate
+            // read from the LIVE registered trigger, and #B246's own answer (cancel +
+            // reveal). `e.isTrusted` scopes it: Enter-key submission and a wrapped-label
+            // click (`<button type="submit"><span>`, whose click target has no `.type`
+            // and so surfaces here instead of at the click proxy) arrive as trusted
+            // submits; gina's own `triggerEvent` (`$forms[id].submit()`) dispatches an
+            // untrusted CustomEvent and stays on the fresh-validate path below — a
+            // programmatic submit is not operating the control, and the fresh pass is
+            // the honest gate there. The reveal re-derives validity from live values,
+            // so a stale marker heals and the NEXT gesture goes through.
+            // Replaces the DOMParser innerHTML-copy guard below: the copy was blind to
+            // the gate's marker (then `aria-disabled`, written by
+            // updateSubmitTriggerState — since #B312 the gate marks its own
+            // `data-gina-form-submit-gated` channel) while SIGHTED on a native `disabled` written
+            // mid-dispatch by a double-submit guard — the exact attribute #B293 ruled
+            // must not count on a real form control — so a wrapped-label trigger plus
+            // a double-submit guard was a dead submit.
+            // was:
+            // // check submit trigger status
+            // var submitTrigger = new DOMParser()
+            //     .parseFromString($target.innerHTML, 'text/html')
+            //     .getElementById($formInstance.submitTrigger);
+            // // prevent submit if disabled
+            // if ( submitTrigger && submitTrigger.disabled) {
+            //     cancelEvent(e);
+            // }
+            if ($formInstance && e.isTrusted) {
+                var $registeredTrigger = document.getElementById($formInstance.submitTrigger) || null;
+                if ( isTriggerDisabled($registeredTrigger) ) {
+                    cancelEvent(e);
+                    revealValidationState($formInstance);
+                    return false;
+                }
             }
 
             // prevent event to be triggered twice
@@ -8437,12 +8537,10 @@ function ValidatorPlugin(rules, data, formId, culture) {
             // the event surfaces here instead. There is no clicked element on this path,
             // so the registered trigger is the best and only referent. Placed after the
             // disabled + defaultPrevented guards above, which both return first.
-            // NB. the disabled check at the top of this handler reads a DOMParser copy of
-            // the form's innerHTML, so it sees neither a live `disabled` set by JS nor the
-            // `aria-disabled` marker `updateSubmitTriggerState` uses. Re-check the live
-            // node with #B246's predicate: without it, every Enter-key submit on an
-            // invalid live-check form would flash the trigger armed for the length of the
-            // validation pass before the rejected branch released it.
+            // NB. the #B308 gesture gate above already cancelled any TRUSTED submit on
+            // a marked trigger, so this skip now guards the UNTRUSTED path: a
+            // programmatic submit on a marked form runs the fresh validate pass below
+            // and must not flash the trigger armed for the length of that pass.
             if ($formInstance) {
                 var $loadingTrigger = document.getElementById($formInstance.submitTrigger);
                 if ( !isTriggerDisabled($loadingTrigger) ) {
@@ -8619,6 +8717,33 @@ function ValidatorPlugin(rules, data, formId, culture) {
 
     } // EO bindForm()
 
+    /**
+     * updateSubmitTriggerState
+     *
+     * Syncs a form's registered submit trigger with the live-check verdict:
+     * while the form is invalid and live checking is on, the trigger is marked
+     * `data-gina-form-submit-gated="true"` plus a styling class (#B312); both
+     * marks are removed the moment the form validates. The marker is the
+     * framework's OWN channel — the trigger carries no ARIA disabled claim,
+     * because it stays genuinely operable: a click on a gated trigger is
+     * answered by the display-only reveal (#B246), and `isValid()` remains the
+     * real send gate.
+     *
+     * `aria-disabled` is deliberately neither written nor cleared here: an
+     * authored mark belongs to the author (the gates enforce it, and nothing
+     * here strips it), and the anchor in-flight lock's mark belongs to the
+     * settle releases in `send()`.
+     *
+     * @param {object|HTMLFormElement} $formInstanceOrTarget - form instance, or its form target
+     * @param {boolean|string} isFormValid - the fresh validity verdict
+     *
+     * @returns {void}
+     *
+     * @example
+     * updateSubmitTriggerState(instance.$forms['checkout'], true);
+     *
+     * @inner
+     */
     var updateSubmitTriggerState = function($formInstanceOrTarget, isFormValid) {
         //console.debug('submitTrigger[isFormValid='+ isFormValid +']: ', $formInstance.submitTrigger)
         var $formInstance = null; // #B176: was an implicit global (undeclared assignment)
@@ -8637,23 +8762,29 @@ function ValidatorPlugin(rules, data, formId, culture) {
         ) {
             console.warn('This might be normal, so do not worry if this form is handled by your javascript: `'+ $formInstance.id +'`\nGina could not complete `updateSubmitTriggerState()`: `submitTrigger` might not be attached to form instance `'+ $formInstance.id +'`\nTo disable this warning, You just need to disable `Form Live Checking on your form by adding to your <form>: `data-gina-form-live-check-enabled=false``')
         } else if ( document.getElementById($formInstance.submitTrigger) ) {
-            // Represent the "invalid + live-check-on" state with aria-disabled + a class
-            // INSTEAD of the native `disabled` property. A natively-disabled <button>
-            // emits no click event at all, so the click cannot be observed and the user
-            // gets no feedback about WHY the trigger is dead. aria-disabled keeps the
-            // trigger focusable and perceivable, and clickProxyHandler INTERCEPTS the
-            // click (#B246) to answer it with a display-only reveal: every invalid field
-            // is rendered and the first is focused, while the submit cycle is never
-            // entered. The trigger is therefore genuinely not operable — which is what
-            // the aria-disabled contract promises assistive tech, and what the earlier
-            // "keep it operable so the click can still validate" shape got wrong: it
-            // left the real submit path reachable from a control announced as disabled.
-            // Mirrors gina's own <a>-tag submit-trigger handling, which already uses
-            // aria-disabled in-flight. The show branch KEEPS clearing native `disabled` so a trigger
-            // rendered `disabled` in markup still enables on valid / when live-check is off.
+            // Represent the "invalid + live-check-on" state with the framework's own
+            // marker — `data-gina-form-submit-gated` + a class — INSTEAD of any
+            // disabled vocabulary (#B312). A natively-disabled <button> emits no click
+            // event at all, so the click could not be observed and the user would get
+            // no feedback about WHY nothing happens; and an ARIA disabled claim would
+            // be dishonest here — the control stays genuinely operable, keeping the
+            // trigger focusable and perceivable, and clickProxyHandler answers its
+            // clicks (#B246) with a display-only reveal: every invalid field is
+            // rendered and the first is focused, while `isValid()` remains the real
+            // send gate. `aria-disabled` is left to its two honest writers — markup or
+            // script AUTHORS (the gates enforce an authored mark, and the show branch
+            // never strips one) and the anchor in-flight lock in `send()` (armed and
+            // released at the request boundary).
+            // was (#B76, retired by #B312): the hide branch wrote an
+            // `aria-disabled="true"` claim and the show branch removed it — one
+            // attribute carrying the gate verdict, authored marks AND the in-flight
+            // lock, a sharing whose collisions produced #B309/#B311/#B313.
             // Tag-agnostic: setAttribute/classList work for both <button> and <a> submit
-            // triggers. Consumers must style the [aria-disabled="true"] /
-            // .gina-form-submit-disabled state (the framework ships no button CSS).
+            // triggers. The show branch KEEPS clearing native `disabled` so a trigger
+            // rendered `disabled` in markup still enables on valid / when live-check is off.
+            // The framework ships a default look for the gated state (see
+            // loading-state.scss); consumers may override or extend via the
+            // [data-gina-form-submit-gated="true"] / .gina-form-submit-disabled hooks.
             var $submitTrigger = document.getElementById($formInstance.submitTrigger);
             if (
                 /^true$/i.test(isFormValid)
@@ -8661,10 +8792,10 @@ function ValidatorPlugin(rules, data, formId, culture) {
                 !/^(true)$/i.test($formInstance.target.dataset.ginaFormLiveCheckEnabled)
             ) { // show submitTrigger
                 $submitTrigger.disabled = false;
-                $submitTrigger.removeAttribute('aria-disabled');
+                $submitTrigger.removeAttribute('data-gina-form-submit-gated');
                 $submitTrigger.classList.remove('gina-form-submit-disabled');
-            } else { // hide submitTrigger (perceivable but not operable, NOT native-disabled)
-                $submitTrigger.setAttribute('aria-disabled', 'true');
+            } else { // hide submitTrigger (gated: marked not-ready, still operable)
+                $submitTrigger.setAttribute('data-gina-form-submit-gated', 'true');
                 $submitTrigger.classList.add('gina-form-submit-disabled');
             }
         }
@@ -8673,19 +8804,43 @@ function ValidatorPlugin(rules, data, formId, culture) {
     /**
      * isTriggerDisabled
      *
-     * Tells whether a submit trigger is currently marked as disabled.
-     * `updateSubmitTriggerState()` marks an invalid form's trigger with
-     * `aria-disabled="true"` rather than the native `disabled` property, so a
-     * native-only check can never see it. The predicate shape mirrors the popin
-     * plugin's own trigger gate, so both subsystems agree on what "disabled"
-     * means for a trigger.
+     * Tells whether a submit trigger must currently be refused. Three marks
+     * count, each with one honest writer (#B312): `updateSubmitTriggerState()`
+     * gates an invalid form's trigger with the framework's own
+     * `data-gina-form-submit-gated="true"` channel; an AUTHORED
+     * `aria-disabled="true"` counts and is never cleared by the framework —
+     * an author's disabled claim is enforced, not second-guessed; and the
+     * anchor in-flight lock marks `aria-disabled` for the request window. The
+     * aria/native arms keep the same shape as the popin and link plugins' own
+     * gates, so the three subsystems still agree on what an authored
+     * "disabled" means for a trigger; the gated arm is validator-only.
+     *
+     * #B293 — the native `disabled` attribute counts ONLY on an element where
+     * `disabled` is not a real IDL property. On a genuine form control the
+     * browser already suppresses the click entirely (measured: a natively
+     * disabled <button> delivers no click event to JS at all), so this gate
+     * never even runs for one — which means the only way the native arm could
+     * fire there was a listener setting the attribute DURING the dispatch. That
+     * is exactly the shape of the near-universal double-submit guard
+     * (`onclick -> this.setAttribute('disabled', …)`), which is bound to the
+     * button and therefore runs before gina's delegated proxy reaches this
+     * check. Accepting it killed the submit outright: `send()` never ran, the
+     * consumer's own handler cleared the attribute again, and every subsequent
+     * click repeated the cycle with nothing marked and a normal-looking button.
+     * On an <a> or a custom element the browser enforces nothing, so there the
+     * attribute is still the only honest signal and is still read.
      *
      * @param {object} $el - candidate trigger (DOMObject)
      *
-     * @returns {boolean} true when the trigger must not be operated
+     * @returns {boolean} true when the trigger's activation must be refused
+     *
+     * @example
+     * isTriggerDisabled($button); // true while the trigger is gated, or carries an authored aria-disabled="true"
      *
      * @example
-     * isTriggerDisabled($button); // true while aria-disabled="true" is set
+     * // <button disabled> never reaches here (the browser eats the click), and a
+     * // `disabled` set mid-click by a double-submit guard is deliberately ignored
+     * isTriggerDisabled($guardedButton); // false
      *
      * @inner
      */
@@ -8693,10 +8848,16 @@ function ValidatorPlugin(rules, data, formId, culture) {
         if ( !$el || typeof($el.getAttribute) != 'function' ) {
             return false;
         }
+        // #B293: `disabled` is only meaningful where the browser does not enforce it.
+        // was: $el.getAttribute('disabled') != null && $el.getAttribute('disabled') != 'false'
+        var nativeCounts = !('disabled' in $el);
         return (
-            $el.getAttribute('disabled') != null && $el.getAttribute('disabled') != 'false'
+            nativeCounts
+            && $el.getAttribute('disabled') != null && $el.getAttribute('disabled') != 'false'
             ||
             $el.getAttribute('aria-disabled') == 'true'
+            ||
+            $el.getAttribute('data-gina-form-submit-gated') == 'true'
         );
     };
 
@@ -8711,7 +8872,9 @@ function ValidatorPlugin(rules, data, formId, culture) {
      * than calling here. That is DELIBERATE: the inline shape is locked by source
      * pins in `test/core/validator-aria-invalid.test.js` (`_a11yErrs`, `_aField`),
      * so collapsing the two would break pins unrelated to #B246. Keep the two in
-     * step if the focus rule ever changes.
+     * step if the focus rule ever changes — as #B319 did: both sites raise the
+     * answer-focus exemption around their loop, so delivering the answer cannot
+     * be mistaken for the user editing the field.
      *
      * @param {object} $form - form target (DOMObject), not the instance
      * @param {object} errors - error map keyed by field name
@@ -8727,29 +8890,37 @@ function ValidatorPlugin(rules, data, formId, culture) {
         if ( !$form || !errors ) {
             return false;
         }
-        for (var i = 0, len = $form.length; i < len; ++i) {
-            var $field  = $form[i];
-            var name    = $field.getAttribute('name');
-            if (
-                name
-                && typeof(errors[name]) != 'undefined'
-                && ( typeof(errors[name].count) != 'function' || errors[name].count() > 0 )
-                && $field.type != 'hidden'
-                && typeof($field.focus) == 'function'
-            ) {
-                $field.focus();
-                // #A11Y5 (V8) — `typeof focus == 'function'` is true for EVERY HTMLElement,
-                // a custom element with neither `tabindex` nor `delegatesFocus` included,
-                // whose focus() is a silent no-op (measured). Without confirming the move,
-                // the loop reported success and stopped on a control that never took focus,
-                // so a failed submit announced nothing. Confirming it is also what makes the
-                // "skips unfocusable controls" contract above true rather than aspirational.
-                if ( typeof(document) === 'undefined' || !document || document.activeElement === $field ) {
-                    return true;
+        // #B319 — raise the one-shot answer-focus exemption so the synchronous
+        // `focusin` dispatched by `$field.focus()` below cannot re-enter the
+        // live-check suppression and hide the message this answer just rendered.
+        isAnswerFocusInProgress = true;
+        try {
+            for (var i = 0, len = $form.length; i < len; ++i) {
+                var $field  = $form[i];
+                var name    = $field.getAttribute('name');
+                if (
+                    name
+                    && typeof(errors[name]) != 'undefined'
+                    && ( typeof(errors[name].count) != 'function' || errors[name].count() > 0 )
+                    && $field.type != 'hidden'
+                    && typeof($field.focus) == 'function'
+                ) {
+                    $field.focus();
+                    // #A11Y5 (V8) — `typeof focus == 'function'` is true for EVERY HTMLElement,
+                    // a custom element with neither `tabindex` nor `delegatesFocus` included,
+                    // whose focus() is a silent no-op (measured). Without confirming the move,
+                    // the loop reported success and stopped on a control that never took focus,
+                    // so a failed submit announced nothing. Confirming it is also what makes the
+                    // "skips unfocusable controls" contract above true rather than aspirational.
+                    if ( typeof(document) === 'undefined' || !document || document.activeElement === $field ) {
+                        return true;
+                    }
                 }
             }
+            return false;
+        } finally {
+            isAnswerFocusInProgress = false;
         }
-        return false;
     };
 
     /**
@@ -9464,6 +9635,27 @@ function ValidatorPlugin(rules, data, formId, culture) {
                                     // trigger end of validation
                                     // console.debug(field +' is the last element to be validated for formId: '+ formId, cb._errors, instance.$forms[formId].errors);
                                     isFormValid = ( cb._errors.count() > 0 ) ? false : true;
+                                    // #B295 — `cb._errors` is `d.getErrors(field)`, which
+                                    // form-validator.js scopes to a SINGLE field, so the flag
+                                    // above means "this field passed", never "the form is
+                                    // valid". Everything below is guarded on `!isFormValid`,
+                                    // so a form that has just become valid got NO update at
+                                    // all: `updateSubmitTriggerState` was never called and the
+                                    // bind-time `aria-disabled` marker survived on a valid
+                                    // form, while `$forms[id].errors` kept listing the field.
+                                    // That was cosmetic until #B246 made the click gate read
+                                    // the marker — then the first click after the query
+                                    // settles is silently eaten.
+                                    // Hand the verdict to the fresh whole-form pass below,
+                                    // exactly as the not-last-field branch already does. It is
+                                    // the only source that can be trusted here: measured with
+                                    // another field left invalid, that pass reports its error
+                                    // while both the field-scoped `cb._errors` AND the in-pass
+                                    // `d.getErrors()` report none — so deciding from either of
+                                    // those would enable the trigger on an invalid form.
+                                    if (isFormValid) {
+                                        needsGlobalReValidation = true;
+                                    }
                                     if (!isFormValid && /^true|false$/i.test(instance.$forms[formId].isValidating)) {
                                         console.debug('[1] Should update error display now ', cb._errors);
                                         instance.$forms[formId].errors = merge(cb._errors, instance.$forms[formId].errors);

package/framework/{v0.6.4 → v0.6.5}/lib/loading-state/src/main.js

@@ -40,16 +40,15 @@
  * ## Configuring the attribute name
  *
  * The name is read from `gina.config.loadingAttribute`, lazily, at every call —
- * `gina.config` is populated after the bundle loads (via `setOptions`), so a value
+ * `gina.config` is populated by the loader after the bundle loads, so a value
  * captured at module-definition time would be stale. A project already built on
  * `data-loading` opts in with:
  *
- * ```html
- * <script src="/js/vendor/gina/gina.min.js"
- *         data-gina-config="{ loadingAttribute: 'data-loading' }"></script>
+ * ```js
+ * gina.setOptions({ loadingAttribute: 'data-loading' });
  * ```
  *
- * or `gina.setOptions({ loadingAttribute: 'data-loading' })`. There is no
+ * There is no
  * auto-detection: a DOM probe reads nothing at rest (the attribute only exists
  * while something is loading) and a stylesheet probe races late-loaded sheets and
  * throws on cross-origin ones. Configuration is explicit by design.

package/framework/{v0.6.4 → v0.6.5}/lib/logger/src/containers/mq/speaker.js

@@ -130,6 +130,35 @@ function MQSpeaker(opt, loggers, cb) {
         // Only bites when something is actually listening on the MQ port; with
         // nothing there the connection is refused and the handle closes itself.
         client.unref();
+        // #B318 — `unref()` covers the socket HANDLE but NOT the pending
+        // `TCPConnectWrap` REQUEST, and a pending request keeps the event loop
+        // alive on its own. The comment above is correct only for the two states
+        // it names: a completed connect, and a REFUSED one (reachable host, no
+        // listener — the peer sends RST, the handle closes itself). It misses the
+        // third: an UNREACHABLE host (powered off, black-holed, a stale
+        // `host_v4` left behind by a DHCP reassignment) answers nothing at all,
+        // so the connect stays pending for the OS timeout — ~75s on macOS — and
+        // the process cannot exit for that whole window. That is exactly the
+        // hang #B276 set out to remove, surviving in the one state neither the
+        // fix nor its comment considered.
+        //
+        // The deadline below is itself `unref`'d, so it never keeps the loop
+        // alive either: it can only fire while something ELSE is holding the
+        // loop open, which during a stalled dial is precisely the connect
+        // request it exists to cancel. `destroy(err)` emits `error`, so the
+        // outcome flows through the established handler below — same callback
+        // contract, same warn text, no new egress path.
+        var connectDeadline = setTimeout(function () {
+            if (client.connecting) {
+                client.destroy(new Error(
+                    'connect ETIMEDOUT ' + host + ':' + port +
+                    ' - MQ host unreachable; giving up (logging transport only)'
+                ));
+            }
+        }, opt.mqConnectTimeout || 2000);
+        connectDeadline.unref();
+        client.once('connect', function () { clearTimeout(connectDeadline); });
+        client.once('error',   function () { clearTimeout(connectDeadline); });
         client.on('error', (data) => {
             var err = data.toString();
             if (cb) {

package/framework/{v0.6.4 → v0.6.5}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gina-framework",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "dependencies": {
     "@rhinostone/busboy": "^1.6.1",
     "@rhinostone/swig": "^2.7.2",

package/gna.js

@@ -15,14 +15,14 @@
 'use strict';
 
 // Framework core — the main gna module (lifecycle hooks, lib, etc.)
-var _gna = require('./framework/v0.6.4/core/gna');
+var _gna = require('./framework/v0.6.5/core/gna');
 
 // SuperController and EntitySuper — loaded from their source modules
-var SuperController = require('./framework/v0.6.4/core/controller');
-var EntitySuper     = require('./framework/v0.6.4/core/model/entity');
+var SuperController = require('./framework/v0.6.5/core/controller');
+var EntitySuper     = require('./framework/v0.6.5/core/model/entity');
 
 // uuid — from the lib registry
-var uuid = require('./framework/v0.6.4/lib/uuid');
+var uuid = require('./framework/v0.6.5/lib/uuid');
 
 module.exports = {