gina 0.6.6 → 0.6.7

package/framework/{v0.6.6 → v0.6.7}/core/controller/controller.js

@@ -3406,12 +3406,24 @@ if ( /^local$/i.test(process.env.NODE_SCOPE) ) {
      * Files are published atomically (temp sibling + rename — #B223), so a
      * reader never observes a partially-written file under the final name.
      *
-     * @param {string} target is the upload dir destination
+     * #STO1 (slice 1) — a file whose upload group carries a `driver` key
+     * (`settings.json > upload.groups.<name>.driver`) is published through the
+     * named `settings.storage` driver instead of moving to `target`; its result
+     * entry then carries an OPAQUE `key` (+ `group`, `driver`, and the layer's
+     * on-disk `size`) and NO `filename` — read it back via
+     * `gina.storage(driver)`. Files in groups without a `driver` keep the
+     * historical move path byte-for-byte, and one call may mix both kinds
+     * (result slots stay 1:1 with the input array). `target` may be `null`
+     * ONLY when every file routes to a driver.
+     *
+     * @param {?string} target is the upload dir destination (required when any
+     *   file is NOT driver-routed)
      * @param {array} [files]
      *
      * @callback [cb]
-     *  @param {Error|boolean} error - `false` on success; the real move `Error`
-     *    on failure (`No file to upload` only when there was nothing to store)
+     *  @param {Error|boolean} error - `false` on success; the real move/publish
+     *    `Error` on failure (`No file to upload` only when there was nothing to
+     *    store)
      *  @param {array} files
      *
      * @event
@@ -3427,9 +3439,106 @@ if ( /^local$/i.test(process.env.NODE_SCOPE) ) {
      *     }
      *     self.renderJSON({ files: files });
      * });
+     *
+     * @example
+     * // a driver-routed group's entries carry a storage key, not a path
+     * self.store(uploadDir, req.files, function onStored(err, files) {
+     *     if (err) { return self.throwError(500, err); }
+     *     // files[i] = { file, filename, size, type, encoding }        (moved)
+     *     // files[i] = { file, group, driver, key, size, type, encoding } (driver-routed)
+     *     self.renderJSON({ files: files });
+     * });
      * */
     this.store = async function(target, files, cb) {
 
+        // #STO1 — per-group storage-driver routing (slice 1). Group config is
+        // read DIRECTLY off the request's resolved bundle conf (a getConfig()
+        // call would clone the whole settings block per store() call); only the
+        // literal `driver` string is consumed here — every placeholder-bearing
+        // upload key stays boot-side territory.
+        var _uploadGroups = ( local.options
+            && local.options.conf
+            && local.options.conf.content
+            && local.options.conf.content.settings
+            && local.options.conf.content.settings.upload
+            && local.options.conf.content.settings.upload.groups
+        ) ? local.options.conf.content.settings.upload.groups : null;
+
+        /**
+         * Resolve a file record's upload group to its configured storage driver
+         * name, or `null` when the group is not driver-routed.
+         *
+         * A record with no `group` routes as `untagged` — the same default the
+         * multipart gate applies — which also covers caller-synthesized file
+         * lists that never went through the parser.
+         *
+         * @inner
+         * @param {object} fileRecord - A `req.files`-shaped record.
+         * @returns {?string} The driver name, or `null` (historical move path).
+         */
+        var getFileDriverName = function(fileRecord) {
+            var g = ( fileRecord && fileRecord.group ) ? fileRecord.group : 'untagged';
+            if ( _uploadGroups
+                && _uploadGroups[g]
+                && typeof(_uploadGroups[g].driver) == 'string'
+                && _uploadGroups[g].driver.length > 0
+            ) {
+                return _uploadGroups[g].driver;
+            }
+            return null;
+        };
+
+        /**
+         * Publish driver-routed entries through `lib/storage`, sequentially —
+         * mirroring `movefiles`: abort on the FIRST failure, keep
+         * already-published objects, and tolerate a source consumed by the
+         * upload tmp-cleanup timer AFTER a successful publish (ENOENT).
+         *
+         * Each entry's pre-filled result slot receives the layer's opaque `key`
+         * and its on-disk `size` on publish.
+         *
+         * @inner
+         * @param {object[]} entries - `{ record, fileName, driverName, slot }` tuples.
+         * @param {function} done - `done(err)` — `false` once every entry published.
+         * @returns {void}
+         */
+        var putfiles = function(entries, done) {
+            var e = 0;
+            var next = function() {
+                if ( e >= entries.length ) {
+                    return done(false);
+                }
+                var entry  = entries[e];
+                var driver = null;
+                try {
+                    driver = lib.storage.get(entry.driverName);
+                } catch (resolveErr) {
+                    return done(resolveErr);
+                }
+                driver.put(fs.createReadStream(entry.record.path), {
+                    originalName : entry.fileName,
+                    contentType  : entry.record.type
+                }, function (putErr, putRes) {
+                    if (putErr) {
+                        return done(putErr);
+                    }
+                    try {
+                        fs.unlinkSync(entry.record.path);
+                    } catch (unlinkErr) {
+                        // the source vanishing AFTER a successful publish is not
+                        // a failure (e.g. the upload tmp-cleanup timer took it)
+                        if (unlinkErr.code != 'ENOENT') {
+                            return done(unlinkErr);
+                        }
+                    }
+                    entry.slot.key  = putRes.key;
+                    entry.slot.size = putRes.size;
+                    ++e;
+                    next();
+                });
+            };
+            next();
+        };
 
         var start = function(target, files, cb) {
 
@@ -3463,10 +3572,57 @@ if ( /^local$/i.test(process.env.NODE_SCOPE) ) {
                 }
             } else {
                 // saving files
-                var uploadDir   = new _(target)
+                var uploadDir   = null
                     , list      = []
                     , i         = 0
-                    , folder    = uploadDir.mkdirSync();
+                    , folder    = null;
+
+                // #STO1 — partition FIRST: a driver-routed file never touches
+                // `target`, so the target dir is only required — and only
+                // created — when at least one file stays on the historical
+                // move path.
+                var fileName    = null
+                    , routed    = []
+                    , unrouted  = [];
+                for (var len = files.length; i < len; ++i ){
+
+                    fileName = files[i].filename || files[i].originalFilename
+
+                    var _driverName = getFileDriverName(files[i]);
+                    if ( _driverName ) {
+                        // slot filled now so the result keeps 1:1 index parity
+                        // with `files`; `key`/`size` land on publish
+                        uploadedFiles[i] = {
+                            file        : fileName,
+                            group       : ( files[i].group ) ? files[i].group : 'untagged',
+                            driver      : _driverName,
+                            key         : null,
+                            size        : files[i].size,
+                            type        : files[i].type,
+                            encoding    : files[i].encoding
+                        };
+                        routed.push({ record: files[i], fileName: fileName, driverName: _driverName, slot: uploadedFiles[i] });
+                        continue;
+                    }
+                    unrouted.push({ record: files[i], fileName: fileName, slotIndex: i });
+                }
+
+                if ( unrouted.length && (target == null || target === '') ) {
+                    // #STO1 — an all-routed call may omit the target; a call
+                    // with files on the move path cannot
+                    var _targetErr = new Error('Controller::store — a target directory is required: `'+ unrouted[0].fileName +'` (group `'+ (( unrouted[0].record.group ) ? unrouted[0].record.group : 'untagged') +'`) is not routed to a storage driver');
+                    if (cb) {
+                        cb(_targetErr)
+                    } else {
+                        self.emit('uploaded', _targetErr)
+                    }
+                    return;
+                }
+
+                if ( unrouted.length ) {
+                    uploadDir   = new _(target);
+                    folder      = uploadDir.mkdirSync();
+                }
 
                 if (folder instanceof Error) {
                     if (cb) {
@@ -3476,22 +3632,19 @@ if ( /^local$/i.test(process.env.NODE_SCOPE) ) {
                     }
                 } else {
                     // files list
-                    var fileName = null;
-                    for (var len = files.length; i < len; ++i ){
-
-                        fileName = files[i].filename || files[i].originalFilename
+                    for (var u = 0, uLen = unrouted.length; u < uLen; ++u ){
 
-                        list[i] = {
-                            source: files[i].path,
-                            target: _(uploadDir.toString() + '/' + fileName)
+                        list[u] = {
+                            source: unrouted[u].record.path,
+                            target: _(uploadDir.toString() + '/' + unrouted[u].fileName)
                         };
 
-                        uploadedFiles[i] = {
-                            file        : fileName,
-                            filename    : list[i].target,
-                            size        : files[i].size,
-                            type        : files[i].type,
-                            encoding    : files[i].encoding
+                        uploadedFiles[unrouted[u].slotIndex] = {
+                            file        : unrouted[u].fileName,
+                            filename    : list[u].target,
+                            size        : unrouted[u].record.size,
+                            type        : unrouted[u].record.type,
+                            encoding    : unrouted[u].record.encoding
                         };
 
                     }
@@ -3509,11 +3662,25 @@ if ( /^local$/i.test(process.env.NODE_SCOPE) ) {
                                 self.emit('uploaded', _moveErr)
                             }
                         } else {
-                            if (cb) {
-                                cb(false, uploadedFiles)
-                            } else {
-                                self.emit('uploaded', false, uploadedFiles)
-                            }
+                            // #STO1 — then the driver-routed files; abort on the
+                            // first failure, keep already-published objects (the
+                            // mover's partial-success semantics — no rollback)
+                            putfiles(routed, function (putErr) {
+                                if (putErr) {
+                                    var _putErr = ( putErr instanceof Error ) ? putErr : new Error(String(putErr));
+                                    if (cb) {
+                                        cb(_putErr)
+                                    } else {
+                                        self.emit('uploaded', _putErr)
+                                    }
+                                } else {
+                                    if (cb) {
+                                        cb(false, uploadedFiles)
+                                    } else {
+                                        self.emit('uploaded', false, uploadedFiles)
+                                    }
+                                }
+                            })
                         }
                     })
                 }

package/framework/{v0.6.6 → v0.6.7}/core/gna.js

@@ -1406,6 +1406,29 @@ isBundleMounted(projects, bundlesPath, getContext('bundle'), function onBundleMo
                                     process.gina._inspectorEventTopics = [];
                                 }
 
+                                // #B350 — opt-in from settings.json `inspector.queries.captureValues`
+                                // (default false). Query statements + timing/shape metadata are always
+                                // captured under the dev/window gate; bound parameter VALUES — and
+                                // value-bearing statement bodies (a document database's resolved body,
+                                // a bulk-insert's inlined records) — reach the console lines and the
+                                // Inspector query log only when this is true. A positional bind array
+                                // has no key names, so the key-based redact library structurally cannot
+                                // cover it; the gate + opt-in are the protection (same contract as the
+                                // AI captureText and events captureArgs opt-ins above). Stored on
+                                // process.gina so connectors read a cheap slot. Fail-closed.
+                                try {
+                                    var _qInspSettings = (typeof gna.getConfig === 'function') ? gna.getConfig('settings') : null;
+                                    var _qInspConf     = (_qInspSettings && _qInspSettings.inspector && _qInspSettings.inspector.queries && typeof _qInspSettings.inspector.queries === 'object')
+                                        ? _qInspSettings.inspector.queries
+                                        : {};
+                                    if (!process.gina) process.gina = {};
+                                    process.gina._inspectorQueryCaptureValues = (_qInspConf.captureValues === true);
+                                } catch (qInspErr) {
+                                    console.warn('[inspector-queries] init skipped: ' + (qInspErr.message || qInspErr));
+                                    if (!process.gina) process.gina = {};
+                                    process.gina._inspectorQueryCaptureValues = false;
+                                }
+
                                 // #INS8 — dev-only auto-start of the standalone Inspector
                                 // bundle (inspector@gina). Best-effort + fail-closed.
                                 // Gated on:
@@ -1564,6 +1587,142 @@ isBundleMounted(projects, bundlesPath, getContext('bundle'), function onBundleMo
                                     console.warn('[render-cache] config validation skipped: ' + (rcErr.message || rcErr));
                                 }
 
+                                // #STO1 — pluggable object storage. Validate the bundle's
+                                // `storage` block, build any connector-backed metadata
+                                // stores, then install the drivers before the first
+                                // request. FATAL (#B57 shape) on an unbuildable config:
+                                // unlike a cache, a storage layer has no safe degraded
+                                // mode — a driver that cannot build would leave put()
+                                // writing nowhere, and a root inside a web-served tree
+                                // would publish every stored object, and the metadata
+                                // database beside them, to anonymous callers.
+                                //
+                                // NOTE this band runs inside server.on('started'), i.e.
+                                // AFTER listen() — so a refusal here exits on an
+                                // already-bound port, exactly as the #AI6 and #RC4 blocks
+                                // above do. A pre-listen refusal means moving the lint
+                                // into core/server.js init() (where the audit trail does
+                                // it); kept here for slice 0 so the feature touches one
+                                // core file instead of two.
+                                try {
+                                    var _stoAll      = config.getInstance();
+                                    var _stoSettings = null;
+                                    try {
+                                        _stoSettings = _stoAll[gna.core.startingApp][env].content.settings.storage;
+                                    } catch (stoConfErr) { _stoSettings = null; }
+
+                                    // #STO1 slice 1 — driver-routed upload groups: collect
+                                    // every bundle's `upload.groups.<g>.driver` bindings as
+                                    // NEUTRAL tuples (owner/driver/path) so the storage lint
+                                    // can refuse a dangling reference. The driver set is
+                                    // process-global (built from the starting app's `storage`
+                                    // block), so EVERY bundle's groups validate against that
+                                    // one set. Built BEFORE the `_stoSettings` gate: a
+                                    // binding with NO storage block at all must fatal, not
+                                    // silently no-op.
+                                    var _stoBindings = [];
+                                    try {
+                                        for (var _stoBb in _stoAll) {
+                                            var _stoBup = ( _stoAll[_stoBb] && _stoAll[_stoBb][env]
+                                                && _stoAll[_stoBb][env].content
+                                                && _stoAll[_stoBb][env].content.settings
+                                                && _stoAll[_stoBb][env].content.settings.upload
+                                            ) ? _stoAll[_stoBb][env].content.settings.upload : null;
+                                            if ( !_stoBup || !_stoBup.groups || typeof(_stoBup.groups) != 'object' ) { continue; }
+                                            for (var _stoBg in _stoBup.groups) {
+                                                var _stoBgrp = _stoBup.groups[_stoBg];
+                                                if ( _stoBgrp && typeof(_stoBgrp.driver) == 'string' && _stoBgrp.driver.length > 0 ) {
+                                                    _stoBindings.push({
+                                                        owner  : _stoBb + '/upload.groups/' + _stoBg,
+                                                        driver : _stoBgrp.driver,
+                                                        path   : ( typeof(_stoBgrp.path) == 'string' ) ? _stoBgrp.path : null
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    } catch (stoBindErr) {
+                                        console.warn('[storage] could not enumerate upload-group driver bindings — the binding lint is degraded for this boot: ' + (stoBindErr.message || stoBindErr));
+                                    }
+
+                                    if ( _stoSettings || _stoBindings.length ) {
+                                        // Web-served roots, INJECTED into the validator so
+                                        // lib/storage stays free of gina core (its
+                                        // import-boundary test enforces that). BOTH
+                                        // surfaces count: a bundle's publicPath, and any
+                                        // content.statics target — a statics mapping can
+                                        // point anywhere on disk, so checking publicPath
+                                        // alone would leave a hole.
+                                        var _stoServed = [];
+                                        try {
+                                            for (var _stoB in _stoAll) {
+                                                var _stoBc = _stoAll[_stoB] && _stoAll[_stoB][env];
+                                                if ( !_stoBc ) { continue; }
+                                                if ( typeof(_stoBc.publicPath) == 'string' && _stoBc.publicPath && !/\$\{/.test(_stoBc.publicPath) ) {
+                                                    _stoServed.push(_stoBc.publicPath);
+                                                }
+                                                var _stoStatics = _stoBc.content && _stoBc.content.statics;
+                                                for (var _stoU in _stoStatics) {
+                                                    if ( typeof(_stoStatics[_stoU]) == 'string' && _stoStatics[_stoU] && !/\$\{/.test(_stoStatics[_stoU]) ) {
+                                                        _stoServed.push(_stoStatics[_stoU]);
+                                                    }
+                                                }
+                                            }
+                                        } catch (stoServedErr) {
+                                            console.warn('[storage] could not enumerate every web-served root — the served-root check is degraded for this boot: ' + (stoServedErr.message || stoServedErr));
+                                        }
+
+                                        var _stoCheck = lib.storage.validateConfig(_stoSettings, { servedRoots: _stoServed, groupBindings: _stoBindings });
+                                        for (var _stoW = 0; _stoW < _stoCheck.warnings.length; _stoW++) {
+                                            console.warn('[storage] ' + _stoCheck.warnings[_stoW]);
+                                        }
+                                        if (_stoCheck.fatal) {
+                                            var _stoFatalMsg = '[storage] invalid storage configuration — aborting boot: ' + _stoCheck.fatal;
+                                            console.emerg(_stoFatalMsg);
+                                            // boot-exit-flush: process.exit() truncates async stdio on a pipe.
+                                            try { fs.writeSync(2, _stoFatalMsg + '\n'); } catch (_e) {}
+                                            process.exit(1);
+                                        }
+
+                                        if (_stoCheck.driverCount > 0) {
+                                            var _stoDrivers = _stoSettings.drivers;
+                                            var _stoStores  = {};
+                                            for (var _stoN in _stoDrivers) {
+                                                if ( typeof(_stoDrivers[_stoN].store) == 'string' && _stoDrivers[_stoN].store.length > 0 ) {
+                                                    try {
+                                                        _stoStores[_stoN] = lib.StorageStore(_stoDrivers[_stoN].store);
+                                                    } catch (stoStoreErr) {
+                                                        var _stoStoreMsg = '[storage] driver `' + _stoN + '` names store `' + _stoDrivers[_stoN].store + '`, which could not be built — aborting boot: ' + (stoStoreErr.message || stoStoreErr);
+                                                        console.emerg(_stoStoreMsg + '\n' + (stoStoreErr.stack || ''));
+                                                        try { fs.writeSync(2, _stoStoreMsg + '\n'); } catch (_e) {}
+                                                        process.exit(1);
+                                                    }
+                                                }
+                                            }
+                                            try {
+                                                // `warn` surfaces the per-root strategy-stamp checks
+                                                // (§4 — a strategy flip on populated storage warns
+                                                // every boot; a hash change warns once). Same sink as
+                                                // the validateConfig warnings above.
+                                                if ( lib.storage.start({ drivers: _stoDrivers, default: _stoSettings.default, stores: _stoStores, warn: function(stoWarnMsg) { console.warn('[storage] ' + stoWarnMsg); } }) ) {
+                                                    // console.info, NOT debug — the shipped
+                                                    // default log level filters debug, and an
+                                                    // operator needs to see which roots went live.
+                                                    console.info('[storage] ' + _stoCheck.driverCount + ' driver(s) ready' + ( _stoSettings.default ? ' (default: ' + _stoSettings.default + ')' : '' ));
+                                                } else {
+                                                    console.warn('[storage] drivers were already installed — this boot wiring was ignored');
+                                                }
+                                            } catch (stoStartErr) {
+                                                var _stoStartMsg = '[storage] drivers could not be built — aborting boot: ' + (stoStartErr.message || stoStartErr);
+                                                console.emerg(_stoStartMsg + '\n' + (stoStartErr.stack || ''));
+                                                try { fs.writeSync(2, _stoStartMsg + '\n'); } catch (_e) {}
+                                                process.exit(1);
+                                            }
+                                        }
+                                    }
+                                } catch (stoErr) {
+                                    console.warn('[storage] config validation skipped: ' + (stoErr.message || stoErr));
+                                }
+
                                 // #CE1 — `server.transientErrors` boot-time shape check
                                 // (warn-only, NEVER fatal: the opt-in governs how a
                                 // transient datastore error RENDERS — a bad value must
@@ -2273,6 +2432,33 @@ gna.getModelEntity = getModelEntity;
  */
 gna.registerBusyProbe = lib.releaseWatch.registerBusyProbe;
 
+/**
+ * #STO1 — get a configured object-storage driver.
+ *
+ * The producer surface for server-GENERATED files (rendered PDFs, exports,
+ * archives): anything that is not an inbound upload. The upload path keeps its
+ * own `self.store()` route for now.
+ *
+ * Assigned UNCONDITIONALLY, so a bundle with no `storage` block gets a named
+ * error naming the fix instead of `gna.storage is not a function` — and so the
+ * declaration is a plain function rather than one the caller must narrow.
+ *
+ * @param {string} [name] - Driver name; omitted returns the `storage.default` driver.
+ * @returns {object} The driver (`put` / `get` / `stat` / `release` / `resolve` / `capabilities`).
+ * @throws {Error} When storage is not configured, when no default is declared and `name`
+ *                 was omitted, or when `name` is not a configured driver.
+ * @example
+ *   gna.storage().put(pdfStream, { originalName: 'invoice.pdf' }, function (err, res) {
+ *       if (err) { return next(err); }
+ *       invoice.storageKey = res.key;   // opaque — store it, never parse it
+ *   });
+ * @example
+ *   gina.storage('archives');  // a named driver
+ */
+gna.storage = function(name) {
+    return lib.storage.get(name);
+};
+
 // ── JSON helper (framework/v*/helpers/json/src/main.js) ──────────────────
 
 /**

package/framework/{v0.6.6 → v0.6.7}/core/plugins/lib/validator/src/form-validator.js

@@ -417,7 +417,22 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
         //  - previous error detected
         if ( !self.isValid() ) {
             console.debug('stopping on errors ...');
-            triggerEvent(gina, this.target, 'asyncCompleted.' + id, self[this['name']]);
+            // #B338 — release ASYNCHRONOUSLY. A synchronous trigger fires the
+            // completion waiter MID-FIELD-LOOP (inside this very field's rule
+            // application), so the pass composed its payload before LATER
+            // fields were adjudicated — a field declared after the query field
+            // vanished from the submit verdict, its rendered error was then
+            // CLEARED by the render pass, and the outcome depended on field
+            // ORDER. A microtask runs once the call stack empties — after the
+            // whole field loop and its terminal block — which is exactly the
+            // shape a real XHR settle already has: one completion timing for
+            // every release path. (`_skipTarget`/`_skipField` are snapshotted:
+            // `this` is not the field object inside the deferred call.)
+            // was: triggerEvent(gina, this.target, 'asyncCompleted.' + id, self[this['name']]);
+            var _skipTarget = this.target, _skipFieldName = this['name'];
+            queueMicrotask(function deferredKnownInvalidRelease() {
+                triggerEvent(gina, _skipTarget, 'asyncCompleted.' + id, self[_skipFieldName]);
+            });
             //return self[this.name];
             return;
         }
@@ -452,6 +467,20 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
 
             }
         } else if (testedValue === this.value) {
+            // #B332 — while an XHR for this very (field, value) is still IN FLIGHT the
+            // cache below has no verdict yet, and the immediate release at the end of
+            // this branch woke every armed waiter with a verdict-less field object —
+            // the submit pass then completed on its sync-only rules and sent while the
+            // authoritative answer was still on the wire. Do nothing here: the pending
+            // request's settle (processQueryResult / releaseQueryWaiter — both clear
+            // the marker first) triggers `asyncCompleted.<id>` and wakes every waiter
+            // with the real verdict. Marker is set right before xhr.send() below.
+            if (
+                this.target && this.target.dataset
+                && this.target.dataset.ginaFormValidatorQueryPending === this.value
+            ) {
+                return self[this.name];
+            }
             // not resending to backend, but in case of cached errors, re display same error message
             var hasCachedErrors = false;
             if (
@@ -472,7 +501,18 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
             }
             // Do not remove this test
             if ( typeof( gina.events[_evt]) != 'undefined' ) {
-                triggerEvent(gina, this.target, _evt, self[this['name']]);
+                // #B338 — same deferral as the known-invalid release above: a
+                // cached-verdict re-check fires synchronously mid-field-loop,
+                // and the waiter it wakes must not compose the pass verdict
+                // before the remaining fields are adjudicated (measured: the
+                // second click on an unchanged registered value delivered a
+                // payload missing every field declared after the query field,
+                // clearing their rendered errors).
+                // was: triggerEvent(gina, this.target, _evt, self[this['name']]);
+                var _cacheTarget = this.target, _cacheFieldName = this['name'];
+                queueMicrotask(function deferredCachedVerdictRelease() {
+                    triggerEvent(gina, _cacheTarget, _evt, self[_cacheFieldName]);
+                });
             }
 
             return self[this.name];
@@ -607,6 +647,17 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
 
         var processQueryResult = function(result) {
 
+            // #B332 — this request has settled: release the in-flight marker BEFORE any
+            // processing (a throw below routes to releaseQueryWaiter, which also clears).
+            // Value-guarded so a newer request's marker — a keystroke re-fired the query
+            // while this one was on the wire — is never cleared by a stale settle.
+            if (
+                _this.target && _this.target.dataset
+                && _this.target.dataset.ginaFormValidatorQueryPending === String(_this.value)
+            ) {
+                delete _this.target.dataset.ginaFormValidatorQueryPending;
+            }
+
             // #B87: a boolean checkbox routed through a `query` rule carries a real
             // boolean — `.toLowerCase()` only applies to string values
             _this.value      = local['data'][_this.name] = (_this.value && typeof(_this.value) == 'string') ? _this.value.toLowerCase() : _this.value;
@@ -737,6 +788,17 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
          */
         var releaseQueryWaiter = function(err) {
             console.warn('[ FormValidator ] `query` result handling failed for field `'+ (_this && _this.name) +'`: '+ ( err && err.message || err ));
+            // #B332 — the failed settle still ends this request: clear the in-flight
+            // marker (value-guarded, same as processQueryResult) or the same-value
+            // fast path would treat the field as pending forever.
+            try {
+                if (
+                    _this.target && _this.target.dataset
+                    && _this.target.dataset.ginaFormValidatorQueryPending === String(_this.value)
+                ) {
+                    delete _this.target.dataset.ginaFormValidatorQueryPending;
+                }
+            } catch (ignorePendingClear) {}
             try {
                 var _releaseId = _this.target && (_this.target.id || _this.target.getAttribute('id'));
                 if (_releaseId) {
@@ -876,6 +938,13 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
                 }
             }// xhr.onload = function () {
 
+            // #B332 — mark the (field, value) as in flight BEFORE the wire call: the
+            // same-value fast path above must not immediate-release a verdict-less
+            // field while this request is pending. Cleared at both settle chokepoints
+            // (processQueryResult / releaseQueryWaiter), value-guarded.
+            if ( _this.target && _this.target.dataset ) {
+                _this.target.dataset.ginaFormValidatorQueryPending = _this.value;
+            }
             if (data) {
                 xhr.send( queryData ); // stringyfied
             }  else {
@@ -1212,15 +1281,14 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
                         }
 
                         try {
-                            // security checks
-                            compiledCondition = compiledCondition.replace(/(\(|\)|return)/g, '');
                             // #SCS1e (2026-04-24) — replaced the two `eval(...)` calls below with
-                            // auditable equivalents. After `$var` substitution (lines 910-920) and
-                            // paren/return strip above, `compiledCondition` is either:
+                            // auditable equivalents. After `$var` substitution (lines 910-920),
+                            // `compiledCondition` is either:
                             //   (a) a regex literal `/<body>/<flags>` (when `/^\//` matches), or
                             //   (b) a binary comparison `<operand><op><operand>` where operand ∈
                             //       {number, "string", true, false, null, undefined} and op ∈
-                            //       {===, !==, ==, !=, <, >, <=, >=}.
+                            //       {===, !==, ==, !=, <, >, <=, >=} — paren/`return`-stripped
+                            //       inside its branch, before the grammar match.
                             // Old eval executed arbitrary JS; any value reaching `$var` substitution
                             // that contained a quote (e.g. user input `bar"; process.exit();//`)
                             // could escape the `"..."` wrapper at line 916 and reach eval as
@@ -1231,6 +1299,18 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
                             // } else {
                             //     isValid = eval(compiledCondition)
                             // }
+                            // #B345 — the paren/`return` strip used to run HERE, before the branch
+                            // decision, so it also mangled every parenthesized regex literal:
+                            // groups were destroyed (`^(a|b)$` compiled as `^a|b$`, rebinding the
+                            // anchors and turning middle alternatives substring-permissive),
+                            // quantified groups were requantified (`(#TAG)?` became `#TA` plus an
+                            // optional `G`), and a literal `return` inside a pattern was deleted —
+                            // all silently, because the stripped text still compiled as a valid
+                            // regex. The strip protects the BINARY-COMPARISON shape only, so it
+                            // now lives inside that branch; the regex branch never evaluates the
+                            // condition as JS (`new RegExp(body, flags).test(value)` — no eval),
+                            // so parentheses there are legitimate syntax and a regex literal is
+                            // compiled exactly as authored.
                             if ( /^\//.test(compiledCondition) ) {
                                 var _scsRegexMatch = compiledCondition.match(/^\/(.+)\/([a-z]*)$/);
                                 if (!_scsRegexMatch) {
@@ -1238,6 +1318,10 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
                                 }
                                 isValid = new RegExp(_scsRegexMatch[1], _scsRegexMatch[2]).test(this.value);
                             } else {
+                                // security checks (#SCS1e) — strip parens/`return` before the
+                                // grammar-locked match; authored parens in a comparison stay
+                                // tolerated (`("a") === ("a")` strips to `"a" === "a"`).
+                                compiledCondition = compiledCondition.replace(/(\(|\)|return)/g, '');
                                 var _SCS_BINARY_RE = /^\s*(null|undefined|true|false|"[^"]*"|-?\d+(?:\.\d+)?)\s*(===|!==|<=|>=|==|!=|<|>)\s*(null|undefined|true|false|"[^"]*"|-?\d+(?:\.\d+)?)\s*$/;
                                 var _scsBinMatch = (typeof(compiledCondition) == 'string') ? compiledCondition.match(_SCS_BINARY_RE) : null;
                                 if (!_scsBinMatch) {