gina 0.6.29 → 0.6.30

package/framework/{v0.6.29 → v0.6.30}/core/controller/controller.render-swig.js

@@ -21,6 +21,34 @@ var releaseBanner = require('./release-banner');
 // Precompiled regex — avoids per-request RegExp allocation (#P3)
 var blacklistRe       = /[<>]/g;
 
+/**
+ * Lazily construct the process-wide render-context AsyncLocalStorage, parked on
+ * `process.gina` so it survives dev-mode `require.cache` eviction of this
+ * delegate (mirrors `process.gina._reqALS` / `_queryALS`). This is the SAME
+ * store the async delegates enter with `.run()`, and the same one the
+ * context-bearing gina filters read in `getRenderCtx()`.
+ *
+ * #B514 — this DEFAULT delegate is `async` and awaits between the per-request
+ * `SwigFilters({...})` call (which stamps the process-wide
+ * `SwigFilters.instance._options` singleton) and the `compiledTemplate(data)`
+ * invocations that run the context-bearing filters. A concurrent request's
+ * stamp lands inside that window, so the resumed render's getUrl / getWebroot /
+ * t / tIcu resolve the OTHER request's context. #TPL1 Tier-2 (#B25) closed this
+ * for the two `-async` delegates only and left the default path — the one every
+ * bundle takes unless it opts into `settings.template.swig.loader` — on the
+ * raced singleton.
+ *
+ * @inner
+ * @returns {AsyncLocalStorage} the shared render-context store
+ */
+function getRenderALS() {
+    if (!process.gina._renderALS) {
+        var AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
+        process.gina._renderALS = new AsyncLocalStorage();
+    }
+    return process.gina._renderALS;
+}
+
 // Inherited from controller.
 // #B61 (completes the #INS10 race fix): ALL per-request deps are captured
 // FUNCTION-scoped inside render() — nothing per-request lives at module scope.
@@ -905,13 +933,27 @@ module.exports = async function render(userData, displayInspector, errOptions, d
         // interleave window is unchanged: with the copy, an interleaved render
         // overwrote the singleton with ITS copy; by reference it overwrites it
         // with ITS options — same wrongness class, zero new exposure.
-        var filters = SwigFilters({
+        var _renderCtx = {
             options     : localOptions,
             isProxyHost : isProxyHost,
             throwError  : self.throwError,
             req         : req,
             res         : res
-        });
+        };
+        var filters = SwigFilters(_renderCtx);
+        // #B514 — enter the render-context store for THIS request, so the
+        // context-bearing filters resolve it from the ALS instead of the
+        // process-wide singleton stamped just above. `enterWith` rather than
+        // `.run()`: render() is a single ~1,900-line async body (the try at
+        // ~:705 spans to ~:2069) whose every `return` would have to move inside
+        // a callback; enterWith propagates the store to every continuation of
+        // the current async context, which is exactly the awaited span between
+        // here and compiledTemplate(data). getRenderCtx() reads the store FIRST
+        // (`_store || SwigFilters.instance._options || self.options`), so the
+        // singleton survives only as the fallback for non-request callers — a
+        // bundle's own mail/cron renderer calling SwigFilters() outside any
+        // render still resolves its own context.
+        getRenderALS().enterWith(_renderCtx);
         try {
 
             // To extends default filters with user defined filters, go to controllers/setup.js

package/framework/{v0.6.29 → v0.6.30}/core/controller/controller.render-v1.js

@@ -8,6 +8,34 @@ const lib = require('./../../lib') || require.cache[require.resolve('./../../lib
 var console = lib.logger;
 // Inherited from controller
 var self, local, SuperController, getData, hasViews, setResources, SwigFilters, headersSent;
+
+/**
+ * Lazily construct the process-wide render-context AsyncLocalStorage, parked on
+ * `process.gina` so it survives dev-mode `require.cache` eviction of this
+ * delegate (mirrors `process.gina._reqALS` / `_queryALS`). This is the SAME
+ * store the async delegates enter with `.run()`, and the same one the
+ * context-bearing gina filters read in `getRenderCtx()`.
+ *
+ * #B514 — this DEFAULT delegate is `async` and awaits between the per-request
+ * `SwigFilters({...})` call (which stamps the process-wide
+ * `SwigFilters.instance._options` singleton) and the `compiledTemplate(data)`
+ * invocations that run the context-bearing filters. A concurrent request's
+ * stamp lands inside that window, so the resumed render's getUrl / getWebroot /
+ * t / tIcu resolve the OTHER request's context. #TPL1 Tier-2 (#B25) closed this
+ * for the two `-async` delegates only and left the default path — the one every
+ * bundle takes unless it opts into `settings.template.swig.loader` — on the
+ * raced singleton.
+ *
+ * @inner
+ * @returns {AsyncLocalStorage} the shared render-context store
+ */
+function getRenderALS() {
+    if (!process.gina._renderALS) {
+        var AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
+        process.gina._renderALS = new AsyncLocalStorage();
+    }
+    return process.gina._renderALS;
+}
 /**
  * Render HTML templates : Swig is the default template engine
  *
@@ -363,13 +391,27 @@ module.exports = async function render(userData, displayInspector, errOptions, d
 
 
         // setup swig default filters
-        var filters = SwigFilters({
+        var _renderCtx = {
             options     : JSON.clone(localOptions),
             isProxyHost : isProxyHost,
             throwError  : self.throwError,
             req         : local.req,
             res         : local.res
-        });
+        };
+        var filters = SwigFilters(_renderCtx);
+        // #B514 — enter the render-context store for THIS request, so the
+        // context-bearing filters resolve it from the ALS instead of the
+        // process-wide singleton stamped just above. `enterWith` rather than
+        // `.run()`: render() is a single ~1,900-line async body (the try at
+        // ~:705 spans to ~:2069) whose every `return` would have to move inside
+        // a callback; enterWith propagates the store to every continuation of
+        // the current async context, which is exactly the awaited span between
+        // here and compiledTemplate(data). getRenderCtx() reads the store FIRST
+        // (`_store || SwigFilters.instance._options || self.options`), so the
+        // singleton survives only as the fallback for non-request callers — a
+        // bundle's own mail/cron renderer calling SwigFilters() outside any
+        // render still resolves its own context.
+        getRenderALS().enterWith(_renderCtx);
 
         try {
 

package/framework/{v0.6.29 → v0.6.30}/core/model/entity.js

@@ -47,8 +47,9 @@ var _callALS = (function () {
  *   queue — or, when that call has already settled (bounded wait, Promise path),
  *   DROP the late completion: it is never handed to whoever is at the head.
  * - No active store, or a store for another trigger: arrival order (`shift()`), the
- *   pre-#B440 pairing, logged at debug so a consumer can see the fallback happen in
- *   their own logs.
+ *   pre-#B440 pairing. The `DISPATCH:NO_CONTEXT` debug line that reports this fallback
+ *   is emitted by the entity's `emit` override (#B441), which every completion passes
+ *   whether or not a dispatcher is attached — this function only pairs.
  *
  * @private
  * @param {Array<function>} q - the trigger's FIFO of pending resolvers
@@ -61,21 +62,27 @@ var _dequeueByIdentity = function (q, e) {
         var idx = q ? q.indexOf(st.r) : -1;
         return idx > -1 ? q.splice(idx, 1)[0] : null;
     }
-    if (q && q.length) { console.debug('[ MODEL ][ ENTITY ] DISPATCH:NO_CONTEXT ' + e + ' (completion reached the entity outside the call\'s async context; pairing by arrival order)'); }
+    // (#B441) the DISPATCH:NO_CONTEXT line is emitted at emit time — see the emit override — so it
+    // fires whether or not anything is pending; arrival-order pairing below is unchanged.
     return q ? q.shift() : null;
 };
 
 /**
  * Removes a settled call's resolver from its trigger's queue, so a completion that
- * arrives after the call settled cannot be paired with it (#B440).
+ * arrives after the call settled cannot be paired with it (#B440), and stamps the
+ * resolver `_settled` (#B441). Every settle path of both call forms — the identity
+ * dispatch, a returned Promise, the bounded `model.emitTimeout` wait — passes through
+ * here, so the stamp is how the entity's `emit` override recognises a completion that
+ * arrives AFTER its call settled (a surplus completion) without consulting the queue.
  *
  * @private
  * @param {EntitySuper} entity - the entity carrying the `_callbacks` queues
  * @param {string} e - trigger name
- * @param {function} r - the resolver to forget
+ * @param {function} r - the resolver to forget; gains a truthy `_settled` property
  * @returns {void}
  */
 var _forget = function (entity, e, r) {
+    if (typeof r === 'function') { r._settled = true; }   // #B441 — read by the emit override
     var q = entity._callbacks[e]; if (!Array.isArray(q)) return;
     var i = q.indexOf(r); if (i > -1) q.splice(i, 1);
 };
@@ -754,18 +761,71 @@ function EntitySuper(conn, caller, injected) {
     }
 
     /**
-     * custom emit based on node.js emit source
-     * Added on 2016-02-09
-     * */
+     * Custom `emit`, based on the node.js EventEmitter emit source (added 2016-02-09).
+     *
+     * Beyond native dispatch it (1) routes a registered trigger with no attached
+     * listener through `setListener`, which buffers the emit into `_arguments` for the
+     * next caller (the historical "emit before the listener is ready" idiom, and the
+     * numbered `<trigger>1`, `<trigger>2` loop variants), (2) bridges whitelisted
+     * triggers onto the Inspector event signal (#EVTBUS), and (3) accounts for
+     * completion signals per call (#B441):
+     *
+     * - The active per-call store (#B440) names this trigger and its resolver is already
+     *   `_settled` ⇒ a SURPLUS completion. It is never buffered — measured before the fix,
+     *   the next detached (`util.promisify`) caller of the method received it as its own
+     *   result, every later caller too, and `_arguments` grew by one entry per surplus
+     *   emit. The second completion of one call logs `DISPATCH:REPEAT_EMIT` once at debug
+     *   level; a single late completion after a Promise or timeout settle stays silent.
+     * - No store, or another trigger's store ⇒ `DISPATCH:NO_CONTEXT` at debug level,
+     *   pending or not: the pre-#B440 arrival-order boundary, now visible even when the
+     *   completion arrives with nothing pending.
+     * - A numbered variant of the store's own trigger is the documented loop idiom and
+     *   is not a completion: silent.
+     *
+     * @param {string} type - event name; for a completion, the `<shortName>#<method>` trigger
+     * @param {...*} args - forwarded to the listeners
+     * @returns {boolean} `true` when at least one listener received the event
+     * @example
+     * // inside an entity method, once per call:
+     * self.emit('user#insert', false, record);
+     */
     this.emit = function emit(type) {
+        // #B441 — completion-signal accounting at EMIT time, for registered triggers only
+        // (numbered loop variants are not in _triggers and are the documented multi-emit idiom).
+        // Both dispatch listeners remove themselves once their queue drains, so a completion of a
+        // call that already settled reaches no dispatcher — the emit is the one place every
+        // completion passes. A SURPLUS completion (this call's resolver already settled: by an
+        // earlier emit, a returned Promise or the bounded wait) must never take the setListener
+        // buffering path below: measured, it was buffered into _arguments and the next detached
+        // (promisify) caller of the method received it as its own result.
+        var _b441Surplus = false;
+        if ( type !== 'error' && self._triggers && self._triggers.indexOf(type) > -1 ) {
+            var _b441St = _callALS.getStore();
+            if ( _b441St && _b441St.e === type ) {
+                _b441St._emits = (_b441St._emits || 0) + 1;
+                if ( _b441St.r && _b441St.r._settled ) {
+                    _b441Surplus = true;
+                    if ( _b441St._emits === 2 ) {
+                        console.debug('[ MODEL ][ ENTITY ] DISPATCH:REPEAT_EMIT ' + type + ' (this method emitted its completion a second time within one call — the caller was settled by the first; this and any later completion are discarded, never buffered for the next caller)');
+                    }
+                }
+            } else if ( _b441St && _b441St.e === type.replace(/[0-9]/g, '') ) {
+                // a numbered variant of this call's own trigger — the documented loop idiom
+                // (`<trigger>1`, `<trigger>2`, …); not a completion, nothing to report
+            } else {
+                // no call context, or another trigger's — the pre-#B440 pairing boundary, now
+                // reported whether or not anything is pending (#B441 limb b)
+                console.debug('[ MODEL ][ ENTITY ] DISPATCH:NO_CONTEXT ' + type + ' (completion reached the entity outside any call\'s async context: paired by arrival order if a call is pending, otherwise buffered for a following promisify-style call)');
+            }
+        }
         // BO Added to handle trigger with increment when `emit occurs whithin a loop or recursive function
-        if (
+        if ( !_b441Surplus && (
             self._triggers && self._triggers.indexOf(type) == -1 && self._triggers.indexOf(type.replace(/[0-9]/g, '')) > -1
             || self._triggers && self._triggers.indexOf(type) > -1 && typeof(self._callbacks[type]) == 'undefined' && typeof(self._events[type]) == 'undefined'
             // #M2 — skip DISPATCH:CALLBACK_FLUSH for queue mode (_callbacks is an array);
             // the persistent .on dispatch listener handles routing in that case.
             || self._triggers && self._triggers.indexOf(type) > -1 && typeof(self._callbacks[type]) != 'undefined' && !Array.isArray(self._callbacks[type])
-        ) {
+        ) ) {
             setListener(arguments)
         }
         // EO Added to handle trigger with increment

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

@@ -1085,11 +1085,19 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
             var attr = options.url.split(/@/);
             rule = attr[0];
             bundle = attr[1];
-            var proxyConf = getConfig( currentBundle, 'app' ).proxy;
             try {
                 if (config.bundle !== bundle) { // ignore if same bundle
                     // getting proxy conf when available
-                    opt = getConfig( currentBundle, 'app' ).proxy[bundle];
+                    // #B522 — clone. The GLOBAL two-argument getConfig() hands back the
+                    // bundle's `app` conf BY REFERENCE, so the `opt.method` / `opt.path`
+                    // writes further down — and the `requestTimeout` controller.query()
+                    // adds to the caller's object before its own defensive copy — used to
+                    // persist on the shared content.app.proxy[<bundle>] for the whole
+                    // process lifetime. `path` and `requestTimeout` are documented
+                    // proxyTarget properties, so that clobbered configured values for
+                    // every other reader of this conf, not merely added stray keys.
+                    // opt = getConfig( currentBundle, 'app' ).proxy[bundle];
+                    opt = JSON.clone( getConfig( currentBundle, 'app' ).proxy[bundle] );
                 }
             } catch (proxyError) {
                 throw new Error('Could not retrieve `proxy` configuration for bundle `'+ bundle +'`. Please check your `/config/app.json`.\n'+proxyError.stack);

package/framework/{v0.6.29 → v0.6.30}/core/router.js

@@ -776,7 +776,15 @@ function Router(env, scope) {
         // options.conf = JSON.clone(conf); // pre-#B52-residual: whole-conf deep clone per request
         options.conf = Object.assign({}, conf);
         options.conf.content = Object.assign({}, conf.content);
-        options.conf.content.routing = JSON.clone(conf.content.routing);
+        // #P40 S3b — a per-rule SHALLOW copy replaces the deep clone of the whole routing
+        // map: the only per-request write below is the [rule].param REPLACEMENT on the
+        // matched rule (a whole-property assignment), and `params.middleware` — the array
+        // processMiddlewares splices — is already this request's own copy from the matcher
+        // (server.js / lib/routing build params with a cloned middleware array). Every other
+        // rule stays shared by reference; the deep clone cost 5 µs at 8 routes and ~290 µs at
+        // 380 on this host, on every matched request, for a map nothing else mutates.
+        options.conf.content.routing = Object.assign({}, conf.content.routing);
+        options.conf.content.routing[options.rule] = Object.assign({}, conf.content.routing[options.rule]);
         // inheriting from _common
         if (
             options.template

package/framework/{v0.6.29 → v0.6.30}/core/server.js

@@ -7739,7 +7739,15 @@ function Server(options) {
         var _reqStore = {
             requestId : req._ginaReqId || _resolveRequestId(req),
             startMs   : (typeof req._ginaReqStartMs === 'number') ? req._ginaReqStartMs : Date.now(),
-            proxy     : null
+            proxy     : null,
+            // #B534 — carry THIS request's trio so a detached callback can answer the
+            // request whose call failed, rather than whichever one the process-wide
+            // `router` context slot happened to see last. The slot (core/router.js) is
+            // never cleared, so under concurrency it is the wrong request as often as
+            // the right one; helpers/context.js's throwError prefers these.
+            req       : req,
+            res       : res,
+            next      : next
         };
         return process.gina._reqALS.run(_reqStore, function() {
             return _handleDispatch(req, res, next, bundle, pathname, config);

package/framework/{v0.6.29 → v0.6.30}/helpers/context.js

@@ -8,9 +8,29 @@
 var fs              = require('fs');
 var os              = require('os');
 const {execSync}    = require('child_process');
+var crypto          = require('crypto');
 //var merge   = require('./../lib/merge');
 //var console = require('./../lib/logger');
 
+/**
+ * #ERRREF — mints the incident ref that an error response returns to the
+ * client and the server-side pairing line is keyed by (#B533 brought this
+ * third `throwError` twin into the contract). Honours a relay-safe
+ * caller-supplied ref (1-32 word chars, dots or dashes), otherwise returns a
+ * fresh mint. Kept byte-identical with the two other copies
+ * (core/server.js + core/controller/controller.js) — test-pinned.
+ *
+ * @private
+ * @param {string} [supplied] - caller/producer-provided ref candidate
+ * @returns {string} the supplied value when relay-safe, else 6 fresh uppercase hex chars
+ */
+var _mintErrorRef = function(supplied) {
+    if ( typeof(supplied) == 'string' && /^[\w.\-]{1,32}$/.test(supplied) ) {
+        return supplied;
+    }
+    return crypto.randomBytes(3).toString('hex').toUpperCase();
+};
+
 /**
  * ContextHelper
  *
@@ -287,27 +307,67 @@ function ContextHelper(contexts) {
             code    = 500
         }
 
+        // #B534 — the `router` context slot (core/router.js) is process-wide and is
+        // never cleared, so it holds whichever request was routed LAST rather than
+        // the one whose call failed. A callback resumed after an await could
+        // therefore answer a stranger's response — writing this error to their
+        // client and leaving its own caller hanging until the server timeout.
+        // Prefer THIS request's AsyncLocalStorage store, which server.js handle()
+        // establishes for every request on both engines and which propagates across
+        // await; fall back to the slot only for a caller that has no store at all
+        // (boot, CLI, cron, worker), which is what the slot was there for.
+        // `process` is guarded because the egress harness stubs it without `.gina`.
+        var _reqStore = ( typeof(process) != 'undefined' && process.gina && process.gina._reqALS )
+            ? process.gina._reqALS.getStore()
+            : null;
+        // `res` and `next` must come from the SAME source: pairing a store response
+        // with the slot's `next` would hand the middleware chain a stale callback.
+        var _fromStore = ( _reqStore && _reqStore.res ) ? true : false;
         var router  = getContext('router')
-            , res   = ( router ) ? router.response : null
-            , next  = ( router ) ? router.next : null
+            , res   = ( _fromStore ) ? _reqStore.res  : ( ( router ) ? router.response : null )
+            , next  = ( _fromStore ) ? _reqStore.next : ( ( router ) ? router.next : null )
         ;
 
         // Live HTTP request we can still write an error response to.
         if ( res && !res.headersSent ) {
-            var hasViews          = router.hasViews
-                , isUsingTemplate = isUsingTemplate // pre-existing: resolves to `undefined` -> JSON branch
-            ;
-
-            if ( !hasViews || !isUsingTemplate ) {
-                res.writeHead(code, { 'Content-Type': 'application/json'} );
-                res.end(JSON.stringify({
-                    status: code,
-                    error: 'Error '+ code +'. '+ err.stack
-                }))
-            } else {
-                res.writeHead(code, { 'Content-Type': 'text/html'} );
-                res.end('<h1>Error '+ code +'.</h1><pre>'+ err.stack + '</pre>')
+            // #ERRREF / #B533 — this twin used to answer with the raw stack in EVERY
+            // scope and record nothing server-side: the client received the
+            // framework's install path, version dir and frames, the operator got no
+            // line at all. It now does what core/server.js and
+            // core/controller/controller.js do: mint a relay-safe incident ref, emit
+            // ONE full-detail pairing line (message + stack + cause, keyed by the
+            // ref) BEFORE the wire write, and shape the wire copy by scope — local
+            // keeps the stack (the dev toolbar reads it; the `error` string is
+            // unchanged there for an Error without a cause), every other scope gets
+            // the message line only, fail-closed on an unset NODE_SCOPE_IS_LOCAL
+            // (the same read as server.js's isLocalScope()). A relay-safe
+            // caller-supplied `err.ref` is honoured, as the twins do.
+            var ref         = _mintErrorRef( ( err && typeof(err) == 'object' && err.ref ) ? err.ref : undefined );
+            var _isLocal    = /^true$/i.test(process.env.NODE_SCOPE_IS_LOCAL);
+            var _isErrObj   = ( err && typeof(err) == 'object' ) ? true : false;
+            var _errDetail  = _isErrObj ? ( err.stack || err.message || String(err) ) : String(err);
+            if ( _isErrObj && err.cause ) {
+                _errDetail += '\ncaused by: '+ ( err.cause.stack || err.cause.message || err.cause );
             }
+            // #B534 — the pairing line must name the request that `res` belongs to. The
+            // router slot carries no request at all, so this used to read `res.req`;
+            // under the slot's concurrency defect that named the WRONG request beside
+            // this error's ref, which is worse than naming none — the ref exists so an
+            // operator can correlate. Prefer the store's request when the store is
+            // what supplied `res`, and keep `res.req` for the fallback path.
+            var _req        = ( _fromStore && _reqStore.req ) ? _reqStore.req : ( ( res.req ) ? res.req : null );
+            console.error('[ CONTEXT ][ '+ ( getContext('bundle') || '-' ) +' ][ ref '+ ref +' ][ req '+ ( ( _req && _req._ginaReqId ) || '-' ) +' ] '+ ( ( _req && _req.method ) || '-' ) +' [ '+ code +' ] '+ ( ( _req && _req.url ) || '-' ) +'\n'+ _errDetail);
+            var _wireDetail = _isLocal ? _errDetail : ( ( _isErrObj && err.message ) ? err.message : String(err) );
+            // #B254 — the former HTML arm of this branch was unreachable (its guard
+            // read a self-assigned, always-undefined local), so this path has only
+            // ever answered JSON; the dead arm is removed rather than made live,
+            // which would have been a behaviour change nobody asked for.
+            res.writeHead(code, { 'Content-Type': 'application/json'} );
+            res.end(JSON.stringify({
+                status  : code,
+                error   : 'Error '+ code +'. '+ _wireDetail,
+                ref     : ref
+            }));
             return;
         }
 

package/framework/{v0.6.29 → v0.6.30}/lib/cmd/framework/tail.js

@@ -113,6 +113,40 @@ function Tail(opt, cmd) {
         var loggers         = console.getLoggers();
         var loggerHelper    = LoggerHelper(loggerOptions, loggers);
         var format          = loggerHelper.format;
+        // #B524 — honour the render mode this process's logger resolved. `loggerOptions.format`
+        // is the logger's ONE precedence rule (`GINA_LOG_FORMAT=json|text` > `GINA_LOG_STDOUT`
+        // truthy ⇒ json > text), resolved once at logger init, so `GINA_LOG_FORMAT=json` on the
+        // `gina tail` process turns the relay into one JSON object per line — the answer for a
+        // container that runs a framework daemon: the daemon discards the bundle's own stdout
+        // once it has started (bundle/start.js, `if (isStarting) return;`), so this relay is
+        // the only path a runtime line has to `kubectl logs`, and it must stay on. Same shape
+        // as the default container's line; the relay payload carries no request context, so
+        // `requestId`/`durationMs` are absent here.
+        var isJsonMode = (loggerOptions && loggerOptions.format === 'json');
+        /**
+         * Renders one relayed payload for stdout in the resolved mode.
+         *
+         * @inner
+         * @param {object} pl - A relayed payload (`group`, `level`, `content`).
+         * @returns {string} The line to write — a newline-terminated JSON object in
+         *  json mode, the coloured `format()` text otherwise.
+         *
+         * @example
+         * process.stdout.write( renderLine({ group: 'api@shop', level: 'info', content: 'ready' }) );
+         */
+        var renderLine = function(pl) {
+            if (isJsonMode) {
+                return JSON.stringify({
+                    ts     : new Date().toISOString(),
+                    level  : pl.level,
+                    bundle : pl.group,
+                    message: pl.content,
+                    group  : pl.group,
+                    msg    : pl.content
+                }) + '\n';
+            }
+            return format(pl.group, pl.level, pl.content);
+        };
 
         var delayedMessages = [];
 
@@ -121,7 +155,7 @@ function Tail(opt, cmd) {
             var i = 0;
             while (i < delayedMessages.length) {
                 let pl = delayedMessages[i];
-                process.stdout.write( format(pl.group, pl.level, pl.content) );
+                process.stdout.write( renderLine(pl) );
                 i++;
             }
             delayedMessages = []
@@ -232,7 +266,7 @@ function Tail(opt, cmd) {
 
                         try {
                             // Main output
-                            process.stdout.write( format(pl.group, pl.level, pl.content) );
+                            process.stdout.write( renderLine(pl) );
 
 
                             if (

package/framework/v0.6.30/lib/conf-view/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "gina-lib-conf-view",
+  "version": "1.0.0",
+  "description": "per-call copy-on-write view over a shared configuration tree: reads pass through, writes land in a private overlay, enumeration materialises the touched subtree once",
+
+  "author": {
+    "name": "Martin Luther ETOUMAN NDAMBWE",
+    "email": "contact@gina.io"
+  },
+  "copyright": "Copyright (c) 2009-2026 Rhinostone <contact@gina.io>",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "src/main",
+  "license": "MIT",
+  "readmeFilename": "README.md"
+}