gina 0.7.1 → 0.7.2

package/framework/{v0.7.1 → v0.7.2}/core/plugins/lib/validator/src/main.js

@@ -2086,7 +2086,17 @@ function ValidatorPlugin(rules, data, formId, culture) {
         uploadStarted   : 'Upload started',
         uploadComplete  : 'Upload complete',
         // #A11Y7/U5 — spoken when a staged file's reset/delete control removes it.
-        fileRemoved     : '%s removed'
+        fileRemoved     : '%s removed',
+        // #B724 (gh#83 part 1) — the visible text for a status-0 XHR settle. It fires for
+        // a true transport failure AND for a reverse-proxy 413 arriving mid-send over
+        // HTTP/2 or a navigation that aborted the request — both of which DID reach the
+        // server. "did not complete" is honest for all three; the old "did not reach the
+        // server" was false for the latter two. Resolved through a11yLabel() so a project
+        // can translate it, which the hardcoded literal could not.
+        transportError  : 'Transport failure: the request did not complete',
+        // #B726 (gh#83 part 3) — spoken once when a submit waits for one of its form's staged
+        // uploads to finish; the submit is sent when the last of them settles.
+        uploadPending   : 'Waiting for the upload to finish…'
     };
 
     /**
@@ -2117,6 +2127,19 @@ function ValidatorPlugin(rules, data, formId, culture) {
         return A11Y_LABELS[key] || '';
     };
 
+    // #B724 (gh#83 part 1) — track page unload once, at module load. A status-0 XHR
+    // settle during a navigation (the browser aborts in-flight requests as the page tears
+    // down) is an abort, not a transport failure; the flag lets the status-0 arm tag the
+    // result `reason: 'unload'` so a consumer's submit-error handler can distinguish it.
+    var _pageIsUnloading = false;
+    if ( typeof(window) != 'undefined' && window.addEventListener ) {
+        window.addEventListener('pagehide', function() { _pageIsUnloading = true; }, true);
+        // #B728 — a page restored from the back-forward cache keeps its JS state, so the flag the
+        // `pagehide` above set would still be true and every later status-0 settle would be tagged
+        // `unload`. The `pageshow` that restores the page ends that unload.
+        window.addEventListener('pageshow', function() { _pageIsUnloading = false; }, true);
+    }
+
     /**
      * announceA11yStatus — announce a non-error status through the form's region.
      *
@@ -4297,7 +4320,13 @@ function ValidatorPlugin(rules, data, formId, culture) {
                         result = {
                             'status'        : 408,
                             'transportError': true,
-                            'error'         : 'Transport failure: the request did not reach the server'
+                            // #B724 (gh#83 part 1) — a status-0 settle also fires for a 413
+                            // arriving mid-send over HTTP/2 and for a navigation that aborted
+                            // the request, both of which DID reach the server. `reason` lets a
+                            // submit-error handler tell an unload-abort (benign) from a real
+                            // transport failure; the text is overridable + honest (see a11yLabel).
+                            'reason'        : _pageIsUnloading ? 'unload' : 'transport',
+                            'error'         : a11yLabel('transportError')
                         };
 
                         $form.eventData.error = result;
@@ -4920,6 +4949,172 @@ function ValidatorPlugin(rules, data, formId, culture) {
         });
     };
 
+    /**
+     * getStagedUploadsInFlight — #B726: the staged uploads of a form whose staging request is
+     * on the wire.
+     *
+     * A staged file input points at its virtual `gina-upload-*` form through
+     * `data-gina-form-virtual`, written on every selection. That form's record carries `sent`,
+     * which `send()` sets only AFTER `xhr.send()` and clears when the request settles (readyState
+     * 4 and the `loadend` fail-safe). So `sent` reads true exactly while a staging request is in
+     * flight — unlike `isSending`, which is claimed before the request opens and stays true for
+     * good when something throws before it is sent.
+     *
+     * `form.elements` is walked so that a staged input reassociated with `form="<id>"` counts.
+     *
+     * @inner
+     * @param {HTMLFormElement} $formEl - the REAL form (never its virtual upload form)
+     * @returns {Array<string>} the ids of the virtual upload forms still in flight; empty when none
+     *
+     * @example
+     * getStagedUploadsInFlight(document.getElementById('profile')); // ['gina-upload-avatar']
+     */
+    var getStagedUploadsInFlight = function($formEl) {
+        var inFlight = [];
+        if ( !$formEl || !$formEl.elements ) {
+            return inFlight;
+        }
+        var $controls = $formEl.elements, $control = null, virtualId = null;
+        for (var c = 0, cLen = $controls.length; c < cLen; ++c) {
+            $control = $controls[c];
+            if ( !$control || $control.type != 'file' || typeof($control.getAttribute) != 'function' ) {
+                continue;
+            }
+            virtualId = $control.getAttribute('data-gina-form-virtual');
+            if (
+                virtualId
+                && typeof(instance.$forms[virtualId]) != 'undefined'
+                && /^true$/i.test(instance.$forms[virtualId].sent)
+                && inFlight.indexOf(virtualId) < 0
+            ) {
+                inFlight.push(virtualId);
+            }
+        }
+        return inFlight;
+    };
+
+    /**
+     * holdSubmitForStagedUploads — #B726: make a submit WAIT while one of its form's staged
+     * uploads is in flight, instead of posting the upload's still-empty hidden fields.
+     *
+     * Called at the top of both submit doors, before the payload is collected. When an upload is
+     * in flight it records ONE wait on the form's record (`stagedUploadWait`), keeps the busy
+     * state the gesture armed, announces the wait once through the form's live region
+     * (`a11yLabel('uploadPending')`) and tells the caller to stop. When the last upload settles,
+     * `resolveStagedUploadWait` either runs `replay` — which re-enters the same door, so the
+     * fields are collected again, now filled — or, if an upload failed, sends nothing.
+     *
+     * A gesture made while a wait is pending adds nothing; one made when a wait is recorded but
+     * nothing is in flight any more drops the wait and goes through.
+     *
+     * @inner
+     * @param {HTMLFormElement} $formEl - the real form being submitted
+     * @param {function} replay - re-runs this submit through the door it came in by
+     * @returns {boolean} true when the submit must stop here: it is waiting, or a wait is pending
+     *
+     * @example
+     * if ( holdSubmitForStagedUploads($form, function() { $form.requestSubmit(); }) ) {
+     *     return; // the submit runs again once the upload settles
+     * }
+     */
+    var holdSubmitForStagedUploads = function($formEl, replay) {
+        var formId = ( $formEl && typeof($formEl.getAttribute) == 'function' ) ? $formEl.getAttribute('id') : null;
+        var $formRecord = ( formId && typeof(instance.$forms[formId]) != 'undefined' ) ? instance.$forms[formId] : null;
+        if ( !$formRecord ) {
+            return false;
+        }
+        var inFlight = getStagedUploadsInFlight($formEl);
+        if ( $formRecord.stagedUploadWait ) {
+            if ( inFlight.length > 0 ) {
+                return true; // one wait per form
+            }
+            // nothing is on the wire any more: a settle this wait never heard of
+            $formRecord.stagedUploadWait = null;
+            return false;
+        }
+        if ( inFlight.length == 0 ) {
+            return false;
+        }
+        $formRecord.stagedUploadWait = { replay: replay, failed: false };
+        announceA11yStatus($formEl, a11yLabel('uploadPending'));
+        if (envIsDev) {
+            try { console.info('[FormValidator][upload] form `#'+ formId +'`: submit waiting for '+ inFlight.length +' staged upload(s) to finish ('+ inFlight.join(', ') +')'); } catch (e) {}
+        }
+        return true;
+    };
+
+    /**
+     * noteStagedUploadSettled — #B726: called by `onUpload` for every staging outcome.
+     *
+     * When the real form has a submit waiting, a failure marks the wait as failed, and the
+     * decision is left to a microtask: it runs after the whole XHR settle has finished — the
+     * hidden fields filled on success, or the error rendered — and even when the rest of
+     * `onUpload` throws. Every outcome of one settle has been recorded by then, including a
+     * success that `onUpload` turned into an error.
+     *
+     * @inner
+     * @param {HTMLFormElement|undefined} $formEl - the real form (`uploadProperties.$form`)
+     * @param {string} status - `success`, or anything else for a failure
+     * @returns {undefined}
+     *
+     * @example
+     * noteStagedUploadSettled(document.getElementById('profile'), 'error');
+     */
+    var noteStagedUploadSettled = function($formEl, status) {
+        var formId = ( $formEl && typeof($formEl.getAttribute) == 'function' ) ? $formEl.getAttribute('id') : null;
+        var $formRecord = ( formId && typeof(instance.$forms[formId]) != 'undefined' ) ? instance.$forms[formId] : null;
+        if ( !$formRecord || !$formRecord.stagedUploadWait ) {
+            return;
+        }
+        if ( status != 'success' ) {
+            $formRecord.stagedUploadWait.failed = true;
+        }
+        var decide = function onStagedUploadSettled() { resolveStagedUploadWait($formEl); };
+        if ( typeof(queueMicrotask) == 'function' ) {
+            queueMicrotask(decide);
+        } else {
+            Promise.resolve().then(decide);
+        }
+    };
+
+    /**
+     * resolveStagedUploadWait — #B726: decide a waiting submit once a staged upload settled.
+     *
+     * Still waiting while another upload of the form is in flight. Otherwise the wait ends: when
+     * every upload succeeded the submit is replayed through its own door; when one failed, or the
+     * form has left the page, nothing is sent and the busy state the gesture armed is released —
+     * unless the form has a request of its own in flight, whose settle owns that state (#B247).
+     * No announcement on a failure: the upload already announced the server's message, and a
+     * second write in the same beat would replace it.
+     *
+     * @inner
+     * @param {HTMLFormElement} $formEl - the real form
+     * @returns {undefined}
+     *
+     * @example
+     * resolveStagedUploadWait(document.getElementById('profile'));
+     */
+    var resolveStagedUploadWait = function($formEl) {
+        var formId = ( $formEl && typeof($formEl.getAttribute) == 'function' ) ? $formEl.getAttribute('id') : null;
+        var $formRecord = ( formId && typeof(instance.$forms[formId]) != 'undefined' ) ? instance.$forms[formId] : null;
+        if ( !$formRecord || !$formRecord.stagedUploadWait ) {
+            return;
+        }
+        var wait = $formRecord.stagedUploadWait;
+        var isDetached = ( typeof($formEl.isConnected) != 'undefined' && !$formEl.isConnected );
+        if ( !isDetached && getStagedUploadsInFlight($formEl).length > 0 ) {
+            return;
+        }
+        $formRecord.stagedUploadWait = null;
+        if ( wait.failed || isDetached ) {
+            if ( !/^true$/i.test($formRecord.isSending) ) {
+                disarmSubmitLoading($formRecord);
+            }
+            return;
+        }
+        wait.replay();
+    };
+
     var onUpload = function(gina, $target, status, id, data) {
 
         var uploadProperties = $target.uploadProperties || null;
@@ -4946,6 +5141,9 @@ function ValidatorPlugin(rules, data, formId, culture) {
         // #R8 slice 2 — the dropzone (if bound) returns to idle at the same
         // single chokepoint
         updateUploadDropzoneState(uploadProperties.dropzoneContainer || null, 'idle');
+        // #B726 — a submit of the real form may be waiting for this upload; it is decided once
+        // this whole settle has run (see noteStagedUploadSettled)
+        noteStagedUploadSettled(uploadProperties.$form, status);
         // parent form
         // var $mainForm = uploadProperties.$form;
         var $uploadTriger = document.getElementById(uploadProperties.uploadTriggerId);
@@ -4975,7 +5173,16 @@ function ValidatorPlugin(rules, data, formId, culture) {
            // console.error('[ mainUploadError ] ', status, data)
             var errMsg = data.message || data.error;
 
-            $error.innerHTML = '<p>'+ errMsg +'</p>';
+            // #B727 — render the server's error message as TEXT, never HTML. A non-JSON
+            // error response is kept verbatim as `result.message` (see the XHR response
+            // handler), so `innerHTML` here parsed a proxy/WAF HTML error page — or a
+            // reflected upload filename (the server rejects a disallowed extension by
+            // echoing the name) — as live markup. textContent closes the injection sink;
+            // the <p> wrapper is kept for the existing styling + fadeIn.
+            $error.textContent = '';
+            var _errP = document.createElement('p');
+            _errP.textContent = errMsg;
+            $error.appendChild(_errP);
             fadeIn($error);
             // #A11Y7/U3 — the container is `display:none` when the text is written and
             // only revealed by the fadeIn above, which is exactly the case where a
@@ -4987,8 +5194,22 @@ function ValidatorPlugin(rules, data, formId, culture) {
             if ( $uploadTriger && $uploadTriger.form ) {
                 announceA11yError($uploadTriger.form, $error.textContent);
             }
-        } else if(!$error && status != 'success') {
-            throw new Error(errMsg)
+        } else if ( status != 'success' ) {
+            // #B731 — no error element. Every error site calls onUpload BEFORE it dispatches
+            // `error.<id>` and the declared `data-gina-form-upload-on-error` callback, so the
+            // throw this branch held (`new Error(undefined)`: `errMsg` is assigned only in the
+            // branch above) cancelled both. The message is announced instead of shown, and the
+            // dispatch goes on.
+            // was: } else if(!$error && status != 'success') {
+            // was:     throw new Error(errMsg)
+            var noSlotMsg = data.message || data.error;
+            noSlotMsg = ( typeof(noSlotMsg) == 'undefined' || noSlotMsg === null ) ? '' : String(noSlotMsg);
+            if ( $uploadTriger && $uploadTriger.form && noSlotMsg != '' ) {
+                announceA11yError($uploadTriger.form, noSlotMsg);
+            }
+            if (envIsDev) {
+                try { console.warn('[FormValidator] upload `#'+ uploadProperties.uploadTriggerId +'`: no error element `#'+ uploadProperties.errorField +'`; the staging error is announced, not shown'); } catch (warnErr) {}
+            }
         } else {
             // #A11Y7/U2 — success is the other end of the `uploadStarted` transition.
             // It lives in this branch rather than at the indicator chokepoint above so
@@ -8005,6 +8226,9 @@ function ValidatorPlugin(rules, data, formId, culture) {
         // or
         // $form.target.dataset.ginaFormIsResetting = true;
         // handleErrorsDisplay($form.target, {});
+        // #B726 — a submit waiting for a staged upload belongs to the binding being torn down:
+        // drop it, so that upload's settle never replays a submit on an unbound form
+        $form.stagedUploadWait = null;
         $form.binded = false;
 
         return $form;
@@ -8651,12 +8875,23 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     var url             = $el.getAttribute('data-gina-form-upload-action');
                     var name            = $el.getAttribute('name');
                     var fileId          = name;
-                    var uploadFormId    = 'gina-upload-' + name.replace(/\[/g, '-').replace(/\]/g, '-' + $form.id);
+                    // #B732 — the virtual form id must be unique per form. A bracketed name
+                    // already carries the form id (once per `]`), but a bracket-less one
+                    // (`doc`) gave `gina-upload-doc` in EVERY form, so two forms with
+                    // same-named staged inputs shared one virtual form: the second form's
+                    // upload filled the first form's hidden fields and left its own empty.
+                    // was: var uploadFormId    = 'gina-upload-' + name.replace(/\[/g, '-').replace(/\]/g, '-' + $form.id);
+                    var uploadFormId    = 'gina-upload-' + name.replace(/\[/g, '-').replace(/\]/g, '-' + $form.id) + ( (/\]/.test(name)) ? '' : '-' + $form.id );
                     $el.setAttribute('data-gina-form-virtual', uploadFormId);
                     var eventOnSuccess  = $el.getAttribute('data-gina-form-upload-on-success');
                     var eventOnError    = $el.getAttribute('data-gina-form-upload-on-error');
                     var eventOnProgress = $el.getAttribute('data-gina-form-upload-on-progress'); // #R8
-                    var errorField    = null;
+                    // #B731 — the error slot is an attribute of THIS file input (default
+                    // `<id>-error`), read once. It was recomputed for every <input> of the real
+                    // form and kept the last one's, so a custom slot was honoured only when the
+                    // file input was the form's last input.
+                    // was: var errorField    = null;
+                    var errorField    = $el.getAttribute('data-gina-form-upload-error') || ( ($el.id) ? $el.id + '-error' : null );
                     // #B572 — which popin, if any, this upload belongs to is decided by
                     // CONTAINMENT (the popin the real form is inside), captured ONCE per
                     // selection and read by every site below — never by "some popin is open"
@@ -8689,10 +8924,31 @@ function ValidatorPlugin(rules, data, formId, culture) {
                         }
 
                         if ( !$uploadForm ) {
-                            try {
-                                $uploadForm = getFormById(uploadFormId) || null;
-                            } catch (noExistingFormErr) {
-                                // do nothing
+                            // #B733 — `getFormById()` returns the validator RECORD, not the form
+                            // element, and every line below treats `$uploadForm` as the element
+                            // (`setAttribute`, `appendChild`). A record is still registered here
+                            // when an earlier selection's virtual form has left the document: a
+                            // popin close wipes the content but nothing destroys that record, so
+                            // after a reopen the next selection threw and sent nothing. A record's
+                            // element is reused only while it is in the document; a detached one
+                            // is destroyed (its own `destroy()` removes its listeners and their
+                            // registry entries, so the new form binds afresh) and a new form is built.
+                            // was:
+                            // try {
+                            //     $uploadForm = getFormById(uploadFormId) || null;
+                            // } catch (noExistingFormErr) {
+                            //     // do nothing
+                            // }
+                            var $knownUpload = instance.$forms[uploadFormId] || null;
+                            if ( $knownUpload && $knownUpload.target && $knownUpload.target.isConnected ) {
+                                $uploadForm = $knownUpload.target;
+                            } else if ( $knownUpload ) {
+                                try {
+                                    $knownUpload.destroy();
+                                } catch (staleUploadErr) {
+                                    // a record that cannot unbind must still never be reused
+                                }
+                                delete instance.$forms[uploadFormId];
                             }
 
                             if (!$uploadForm) {
@@ -8783,7 +9039,8 @@ function ValidatorPlugin(rules, data, formId, culture) {
                                         fieldType   = formInputsFields[h].getAttribute('type');
                                         hiddenField = null;
                                         _name       = null, _userName = null;
-                                        errorField= formInputsFields[h].getAttribute('data-gina-form-upload-error') || fieldId + '-error' || null;
+                                        // #B731 — read once from the file input, above
+                                        // was: errorField= formInputsFields[h].getAttribute('data-gina-form-upload-error') || fieldId + '-error' || null;
 
                                         if (fieldType && /hidden/i.test(fieldType) ) {
                                             hiddenField = formInputsFields[h];
@@ -8906,6 +9163,14 @@ function ValidatorPlugin(rules, data, formId, culture) {
                             if (eventOnProgress) {
                                 $uploadForm.setAttribute('data-gina-form-event-on-upload-progress', eventOnProgress);
                             }
+                            // #B729 — a file chosen while this input's previous staging request is
+                            // still on the wire supersedes that request: the input now shows the new
+                            // file, so only the new file's metadata may reach the form. Without this
+                            // the one-request-at-a-time gate in send() returned silently, the new
+                            // selection was never sent, and the earlier request filled the form with
+                            // the file the user had just replaced. A superseded request settles
+                            // through `abort.<id>` only: no error, no on-error callback.
+                            $uploadForm.setAttribute('data-gina-form-sync', 'replace');
 
 
                             // adding for to current document
@@ -10243,6 +10508,13 @@ function ValidatorPlugin(rules, data, formId, culture) {
                 //     return;
                 // }
 
+                // #B726 (gh#83 part 3) — a staged upload of this form still on the wire would post
+                // its hidden fields empty: wait for it, then re-run this click, which collects them
+                // again once filled. Placed before the latch below, so there is nothing to release.
+                if ( holdSubmitForStagedUploads($target, function replayStagedUploadClick() { triggerEvent(gina, $submit, evt); }) ) {
+                    return;
+                }
+
                 var validatorInfos = getFormValidationInfos($target, rules);
                 fields  = validatorInfos.fields;
                 $fields = validatorInfos.$fields;
@@ -10499,6 +10771,14 @@ function ValidatorPlugin(rules, data, formId, culture) {
                 cancelEvent(e);
             }
 
+            // #B726 (gh#83 part 3) — the same wait as the click door: a click inside the button,
+            // Enter in a form with no submit button, `<input type=submit>`, requestSubmit() and
+            // `$forms[id].submit()` all arrive here. Only once the native submit is cancelled above:
+            // an earlier return would let the browser post the form itself.
+            if ( (withRules || isBinded) && holdSubmitForStagedUploads($target, function replayStagedUploadSubmit() { triggerEvent(gina, $target, 'submit'); }) ) {
+                return false;
+            }
+
 
             // just collect data over forms
             // getting fields & values
@@ -10560,6 +10840,10 @@ function ValidatorPlugin(rules, data, formId, culture) {
                         fields[name] = '';
                     }
 
+                } else if ( $target[i].type == 'file' && $target[i].getAttribute('data-gina-form-upload-action') ) {
+                    // #B725 (gh#83 part 2) — a staged file input's `.value` is the browser
+                    // placeholder `C:\fakepath\<name>`; its real data travels through the
+                    // staged hidden fields, so keep it out of the XHR payload.
                 } else {
                     fields[name]    = $target[i].value;
                 }
@@ -11421,6 +11705,11 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     fields[name] = '';
                 }
 
+            } else if ( $form[i].type == 'file' && $form[i].getAttribute('data-gina-form-upload-action') ) {
+                // #B725 (gh#83 part 2) — a staged file input's `.value` is the browser
+                // placeholder `C:\fakepath\<name>`; its real data travels through the staged
+                // hidden fields, so keep it out of the XHR payload. The element is still
+                // registered in `$fields` below for any rule that inspects it.
             } else {
                 fields[name] = $form[i].value;
             }

package/framework/{v0.7.1 → v0.7.2}/core/server.isaac.js

@@ -400,6 +400,61 @@ function ServerEngineClass(options) {
         return fs.readFileSync(filename).toString()
     }
 
+    /**
+     * Appends field names to a response's `Vary` header (RFC 9110 § 12.5.5).
+     * `Vary` is a list, so a value already set (by a middleware, by the
+     * configured `server.response.header`, or by the caller) is kept: a name
+     * already listed, in any case, is not added again, and nothing is added
+     * after a `*`, which already varies on everything. Takes one name, a
+     * comma-separated list, or an array of either, so a value read back with
+     * `getHeader('vary')` can be passed straight in to restore it. Does nothing
+     * once the headers are sent. Keep in sync with the twin in core/server.js
+     * (#B743).
+     *
+     * @inner
+     * @private
+     * @param {object} response - Server response object (HTTP/1.x, or the HTTP/2 compatibility API)
+     * @param {string|string[]|null|undefined} names - Field name(s) to add; an empty value adds nothing
+     * @returns {void}
+     *
+     * @example
+     * // Vary: Origin  →  Vary: Origin, Accept-Encoding
+     * appendVary(response, 'Accept-Encoding');
+     */
+    var appendVary = function(response, names) {
+        if (
+            !response
+            || typeof(response.getHeader) != 'function'
+            || typeof(response.setHeader) != 'function'
+            || response.headersSent
+        ) {
+            return;
+        }
+        var list = ( Array.isArray(names) ) ? names.join(',') : names;
+        if ( typeof(list) == 'undefined' || list === null || String(list).trim() === '' ) {
+            return;
+        }
+        var current = response.getHeader('vary');
+        if ( Array.isArray(current) ) {
+            current = current.join(', ');
+        }
+        current = ( typeof(current) == 'undefined' || current === null ) ? '' : String(current).trim();
+        var present = ( current === '' ) ? [] : current.toLowerCase().split(',').map(function(n) { return n.trim(); });
+        var added = [];
+        String(list).split(',').forEach(function(n) {
+            n = n.trim();
+            if ( n === '' || present.indexOf('*') > -1 || present.indexOf(n.toLowerCase()) > -1 ) {
+                return;
+            }
+            present.push(n.toLowerCase());
+            added.push(n);
+        });
+        if ( added.length == 0 ) {
+            return;
+        }
+        response.setHeader('vary', ( current === '' ) ? added.join(', ') : current +', '+ added.join(', '));
+    }
+
     var preferedEncoding    = options.preferedCompressionEncodingOrder
         , acceptEncodingArr = null
         , acceptEncoding    = null
@@ -2493,20 +2548,19 @@ function ServerEngineClass(options) {
             }
 
 
-            if (
-                request.method.toUpperCase() === 'GET' && /\_gina\/assets\/routing\.json(?:\?|$)/i.test(request.url)
-            ) {
+            // #P48 — the path alone: a versioned fetch carries `?v=<token>` (request.url
+            // is query-stripped only further down). #B707 — the lookup is lower-cased to
+            // agree with the case-insensitive test (`findOne` compares strictly, so a
+            // `Routing.json` GET found nothing and dereferenced null below — an
+            // uncaughtException that killed the bundle), and a miss falls through to the
+            // shared pipeline, whose handler answers from memory or 404s.
+            var _routingPath = ( request.method.toUpperCase() === 'GET' ) ? request.url.split('?')[0] : null;
+            localAsset = ( _routingPath && /\_gina\/assets\/routing\.json$/i.test(_routingPath) )
+                ? assetsCollection.findOne({ file: _routingPath.split(/\//g).slice(-1).toString().toLowerCase() })
+                : null;
+            if ( localAsset ) {
                 // server.toApi(reques, response)
                 // console.debug('[ SERVER ][200] '+ request.url);
-                // #B717 — a query string no longer misses the handler (`(?:\?|$)`), and the asset
-                // lookup reads the file name the test matched: the url's last segment of
-                // `routing.json?x` named no asset, and the `localAsset.mime` read below would
-                // have thrown. Not the query-free path's last segment either — the test also
-                // matches `/x?y=/_gina/assets/routing.json`, whose path names `x`.
-                // #B707 — the name is lower-cased: the test is case-insensitive while `findOne`
-                // compares strictly, so `Routing.json` named no asset and the `localAsset.mime`
-                // read below threw — an uncaughtException that ended the process.
-                localAsset = assetsCollection.findOne({ file: /\_gina\/assets\/(routing\.json)(?:\?|$)/i.exec(request.url)[1].toLowerCase() });
                 // #B66 — on a proxied deployment serve the host-stripped routing.json so
                 // the browser never receives any bundle's INTERNAL scheme://host:port (an
                 // information disclosure) and cross-bundle client toUrl resolves
@@ -2528,6 +2582,14 @@ function ServerEngineClass(options) {
                     : ( options.clientRoutingAssets ? options.clientRoutingAssets.fullEtag : null );
                 response.setHeader('content-type', localAsset.mime);
                 response.setHeader('vary', 'Origin');
+                // #B743 — in production the table's precompressed copy (`.br`, `.gz`)
+                // is served when the request accepts its coding (below), over both
+                // protocols, so the answer varies on Accept-Encoding too. Set before the
+                // ETag 304 below, so the 304 carries the Vary its 200 would (RFC 9110
+                // § 15.4.5).
+                if ( !isCacheless ) {
+                    appendVary(response, 'Accept-Encoding');
+                }
                 // #B66 — a shared cache must not cross-serve the stripped (proxied) and
                 // full (raw) variants under the same URL; mark the proxied variant
                 // private. Slice 3 (SPA Tier 1): `no-cache` = revalidate-before-use — each
@@ -2535,6 +2597,19 @@ function ServerEngineClass(options) {
                 // new route table reaches returning browsers immediately instead of
                 // after the old 24h max-age window.
                 response.setHeader('cache-control', ( request._ginaIsProxyHost === true ) ? 'private, no-cache' : 'public, no-cache');
+                // #P48 — a request naming the token of the variant actually served (the
+                // page's `data-gina-routing-v`) may keep the table for a year; mirrors the
+                // core/server.js handler (the /_gina/* sync rule). Keyed on the file served,
+                // so the full map is never marked immutable under the stripped token.
+                var _routingAssetVersion = ( options.clientRoutingAssets )
+                    ? ( ( localAsset.file === 'routing.stripped.json' ) ? options.clientRoutingAssets.strippedVersion : options.clientRoutingAssets.fullVersion )
+                    : null;
+                if (
+                    _routingAssetVersion
+                    && lib.sri.getRequestedVersion(request.originalUrl || request.url) === _routingAssetVersion
+                ) {
+                    response.setHeader('cache-control', ( ( request._ginaIsProxyHost === true ) ? 'private' : 'public' ) + ', max-age=31536000, immutable');
+                }
                 response.setHeader('x-content-type-options', 'nosniff');
                 response.setHeader('x-frame-options', 'DENY');
                 response.setHeader('x-xss-protection', '1; mode=block');
@@ -2553,10 +2628,14 @@ function ServerEngineClass(options) {
                 }
 
                 var filename  =  _(localAsset.path +'/'+ localAsset.file, true);
+                // #B742 — the coding's NAME (`gzip`), kept beside its file extension
+                // (`acceptEncoding`, `.gz`): Content-Encoding takes the name.
+                var acceptEncodingName = null;
                 if (acceptEncodingArr) {
                     for (let e=0, eLen=preferedEncoding.length; e<eLen; e++) {
                         if ( acceptEncodingArr && acceptEncodingArr.indexOf(preferedEncoding[e]) > -1 ) {
                             acceptEncoding = options.coreConfiguration.encoding[ preferedEncoding[e] ] ;
+                            acceptEncodingName = preferedEncoding[e];
                             break;
                         }
                     }
@@ -2570,7 +2649,10 @@ function ServerEngineClass(options) {
                     isBinary = true;
                     filename += acceptEncoding;
                     // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Encoding
-                    response.setHeader('content-encoding', acceptEncoding.replace(/^\./, ''));
+                    // was: response.setHeader('content-encoding', acceptEncoding.replace(/^\./, ''));
+                    // #B742 — the extension without its dot is not a coding name for gzip
+                    // (`gz`), and a browser does not decode such a response.
+                    response.setHeader('content-encoding', acceptEncodingName);
                     // override content length
                     response.setHeader('content-length', fs.statSync(filename).size);
                 }