gina 0.5.6 → 0.5.7

package/framework/v0.5.7/core/connectors/sqlite/lib/job-store.js

@@ -0,0 +1,263 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+'use strict';
+
+/**
+ * @module gina/core/connectors/sqlite/job-store
+ *
+ * SQLite-backed `JobStore` for the async-job primitive (`lib/job`) — the
+ * connector-backed store follow-up of #AI6. Backed by `node:sqlite` (Node.js
+ * built-in since 22.5.0 — zero npm deps), the same substrate as the framework
+ * state store (`lib/state`) and the SQLite session store.
+ *
+ * What it buys over the default memory store: job records survive a bundle
+ * restart (a client polling `/_gina/jobs/:id` keeps resolving across a
+ * deploy), and are visible to any process that opens the same file. The
+ * deferred *function* still runs only in the process that created the job —
+ * the store shares the record, never the closure (see `lib/job`).
+ *
+ * Deliberate divergences from the SQLite SESSION store (same file family,
+ * different contract):
+ *   - `get` / `list` do NOT filter on expiry. The memory store returns
+ *     terminal records until `sweep` purges them, and behavioral parity with
+ *     the memory store is the contract here — expiry acts only at sweep time.
+ *   - No internal cleanup timer. `lib/job` owns the sweep cadence and calls
+ *     `sweep(now, fn)` itself.
+ *
+ * Constructed by the `lib/job-store` dispatcher at boot; not meant to be
+ * instantiated from application code.
+ */
+
+/**
+ * Job lifecycle states — imported so the sweep predicate can never drift from
+ * the memory store's (`lib/job` is a plain-required module-singleton; there is
+ * no load-time cycle because `lib/job` never requires this file — the
+ * `lib/job-store` dispatcher requires it lazily at boot).
+ *
+ * @inner
+ * @type {{PENDING:string, RUNNING:string, COMPLETED:string, FAILED:string}}
+ */
+var STATES = require('../../../../lib/job/src/main').STATES;
+
+/**
+ * No-op callback used when a caller omits one.
+ * @inner
+ * @returns {void}
+ */
+function noop() {}
+
+/**
+ * Build a SQLite-backed job store implementing the `lib/job` `JobStore` seam
+ * (`set / get / remove / list / sweep`, all Node-callback-shaped). Callbacks
+ * fire synchronously (`node:sqlite`'s `DatabaseSync` is a synchronous driver),
+ * so the store has the same timing semantics class as the memory store.
+ *
+ * @param {object}  connConf        - Resolved `connectors.json` entry for this store.
+ * @param {string}  [connConf.file] - Path to the SQLite file, or `':memory:'` (volatile —
+ *                                    only useful in tests). Defaults to
+ *                                    `~/.gina/{version}/jobs-{bundle}.db`.
+ *                                    `file` is the PATH key by the sqlite DB-connector
+ *                                    convention — the model layer scans every
+ *                                    connectors.json entry at boot and treats `database`
+ *                                    as a NAME (`~/.gina/{version}/{database}.sqlite`),
+ *                                    so a path in `database` fails the boot before this
+ *                                    store is even built.
+ * @param {string}  bundle          - Bundle name — used for the default file name.
+ * @returns {object}                - A `JobStore` instance, plus a `close()` convenience
+ *                                    (not part of the seam; releases the file handle).
+ * @throws {Error}                  - On Node < 22.5.0 (no `node:sqlite`) or when the
+ *                                    database file cannot be opened.
+ *
+ * @example
+ *   // connectors.json:  { "jobsDb": { "connector": "sqlite", "file": "/data/jobs.db" } }
+ *   // app.json:         { "jobs": { "store": "jobsDb" } }
+ *   // (wired automatically at boot by gna.js via lib/job-store)
+ */
+module.exports = function SqliteJobStore(connConf, bundle) {
+    connConf = connConf || {};
+
+    // Require node:sqlite — available as a built-in since Node 22.5.0, zero npm deps.
+    var DatabaseSync;
+    try {
+        DatabaseSync = require('node:sqlite').DatabaseSync;
+    } catch (e) {
+        throw new Error(
+            '[SqliteJobStore] node:sqlite requires Node.js >= 22.5.0. '
+            + 'Current: ' + process.version + '\n'
+            + e.message
+        );
+    }
+
+    // Resolve DB path: connectors.json `file` > default per-bundle file. The
+    // default branch is the only place the injected `_` / `getPath` globals
+    // are read, so a test passing an explicit `file` stays standalone.
+    var dbPath = connConf.file
+        || _(getPath('gina').home + '/jobs-' + (bundle || 'bundle') + '.db', true);
+
+    var db = new DatabaseSync(dbPath);
+
+    // WAL + synchronous=NORMAL: same trade-off as the SQLite session store —
+    // concurrent readers never block the writer; a crash can lose the last
+    // committed transaction but never corrupts the database.
+    db.exec('PRAGMA journal_mode=WAL');
+    db.exec('PRAGMA synchronous=NORMAL');
+
+    // Schema bootstrap — idempotent. Thin indexed columns for the two query
+    // shapes (list-by-state, sweep-by-expiry); the full record rides as JSON
+    // because it legitimately gains keys after creation (webhookDeliveredAt,
+    // webhookFailed, ...). All timestamps are epoch MILLISECONDS — the seam's
+    // unit (`sweep(now)` receives `Date.now()`).
+    db.exec(
+        'CREATE TABLE IF NOT EXISTS jobs ('
+        + '  id         TEXT    PRIMARY KEY,'
+        + '  state      TEXT    NOT NULL,'
+        + '  expires_at INTEGER,'
+        + '  updated_at INTEGER NOT NULL,'
+        + '  record     TEXT    NOT NULL'
+        + ')'
+    );
+    db.exec('CREATE INDEX IF NOT EXISTS jobs_state ON jobs (state)');
+    db.exec('CREATE INDEX IF NOT EXISTS jobs_expires ON jobs (expires_at)');
+
+    // Prepare reusable statements once — avoids re-parsing SQL on every call.
+    var stmtUpsert    = db.prepare('INSERT OR REPLACE INTO jobs (id, state, expires_at, updated_at, record) VALUES (?, ?, ?, ?, ?)');
+    var stmtGet       = db.prepare('SELECT record FROM jobs WHERE id = ?');
+    var stmtDel       = db.prepare('DELETE FROM jobs WHERE id = ?');
+    var stmtListAll   = db.prepare('SELECT record FROM jobs');
+    var stmtListState = db.prepare('SELECT record FROM jobs WHERE state = ?');
+    var stmtSweep     = db.prepare(
+        'DELETE FROM jobs WHERE expires_at IS NOT NULL AND expires_at <= ?'
+        + ' AND state IN (\'' + STATES.COMPLETED + '\', \'' + STATES.FAILED + '\')'
+    );
+
+    return {
+
+        /**
+         * Upsert `record` under `id`. The record is serialised whole; `state`
+         * and `expiresAt` are additionally mirrored into their indexed columns.
+         *
+         * @param {string}    id
+         * @param {JobRecord} record
+         * @param {function}  [fn] - `fn(err, record)`.
+         * @returns {void}
+         */
+        set: function(id, record, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            var json;
+            try {
+                json = JSON.stringify(record);
+            } catch (err) {
+                return fn(err);
+            }
+            try {
+                stmtUpsert.run(
+                    id,
+                    String(record.state || ''),
+                    (typeof record.expiresAt === 'number') ? record.expiresAt : null,
+                    (typeof record.updatedAt === 'number') ? record.updatedAt : Date.now(),
+                    json
+                );
+                fn(null, record);
+            } catch (err) {
+                fn(err);
+            }
+        },
+
+        /**
+         * Fetch a record by `id`. No expiry filter — a terminal record past its
+         * `expiresAt` stays readable until `sweep` purges it (memory-store parity).
+         *
+         * @param {string}   id
+         * @param {function} fn - `fn(err, record|null)`.
+         * @returns {void}
+         */
+        get: function(id, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            var row;
+            try {
+                row = stmtGet.get(id);
+            } catch (err) {
+                return fn(err);
+            }
+            if (!row) return fn(null, null);
+            try {
+                return fn(null, JSON.parse(row.record));
+            } catch (parseErr) {
+                return fn(new Error('[SqliteJobStore] could not parse job record `' + id + '`: ' + parseErr.message));
+            }
+        },
+
+        /**
+         * Delete a record by `id`.
+         *
+         * @param {string}   id
+         * @param {function} [fn] - `fn(err, existed)`.
+         * @returns {void}
+         */
+        remove: function(id, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            try {
+                var res = stmtDel.run(id);
+                fn(null, res.changes > 0);
+            } catch (err) {
+                fn(err);
+            }
+        },
+
+        /**
+         * List records, optionally filtered by `{ state }`. No expiry filter
+         * (memory-store parity). A record that fails to parse fails the whole
+         * list loudly — silent skipping would hide corruption.
+         *
+         * @param {?Object}  filter - e.g. `{ state: 'failed' }`; `null` for all.
+         * @param {function} fn     - `fn(err, records)`.
+         * @returns {void}
+         */
+        list: function(filter, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            try {
+                var rows = (filter && filter.state) ? stmtListState.all(String(filter.state)) : stmtListAll.all();
+                var out  = [];
+                for (var i = 0; i < rows.length; i++) {
+                    out.push(JSON.parse(rows[i].record));
+                }
+                fn(null, out);
+            } catch (err) {
+                fn(err);
+            }
+        },
+
+        /**
+         * Purge terminal (`completed` / `failed`) records whose `expiresAt` has
+         * elapsed — the exact memory-store predicate, expressed as one DELETE.
+         *
+         * @param {number}   now - Epoch ms (passed in by `lib/job`).
+         * @param {function} fn  - `fn(err, removedCount)`.
+         * @returns {void}
+         */
+        sweep: function(now, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            try {
+                var res = stmtSweep.run(now);
+                fn(null, res.changes);
+            } catch (err) {
+                fn(err);
+            }
+        },
+
+        /**
+         * Release the underlying file handle. NOT part of the `JobStore` seam —
+         * `lib/job` never calls it; provided for tests and explicit teardown.
+         *
+         * @returns {void}
+         */
+        close: function() {
+            try { db.close(); } catch (e) { /* already closed */ }
+        }
+    };
+};

package/framework/{v0.5.6 → v0.5.7}/core/controller/controller.render-json.js

@@ -7,12 +7,15 @@ var statusCodes         = requireJSON( _( getPath('gina').core + '/status.codes'
 // Inspector secret redaction (dev-mode only — never touches the actual response body)
 var inspectorRedact     = require('lib/inspector-redact');
 
-// Inherited from controller
-var self                = null
-    , local             = null
-    , headersSent       = null
-    , cachePath         = null
-;
+// Inherited from controller.
+// #B63 (sibling of the render-swig #B61 / render-stream #B62 race fixes):
+// the per-request deps are FUNCTION-scoped inside renderJSON() and threaded
+// into the module-level writeCache() as parameters — nothing per-request
+// lives at module scope. In prod this module is a shared singleton across
+// concurrent requests; a module-scoped capture is reassigned by every
+// incoming renderJSON, so writeCache resumed after its writeFile await
+// reading a CONCURRENT request's controller (measured: the cache-config
+// error path reported through the other request's throwError).
 
 
 /**
@@ -24,29 +27,35 @@ var self                = null
  * @param {string} bundle      - Bundle name (used as cache-key namespace)
  * @param {object} opt         - Server cache configuration (`opt.path`, `opt.ttl`)
  * @param {string} jsonContent - Serialised JSON string to cache
+ * @param {object} req         - Per-request request captured by renderJSON (race-safe)
+ * @param {object} res         - Per-request response captured by renderJSON (race-safe)
+ * @param {boolean|string} cacheIsEnabled - Server-level cache flag threaded by renderJSON
+ * @param {function} throwError - Render-scoped controller `throwError` (closure-bound), threaded
+ *                               for the `invalidateOnEvents` validation branch
  * @returns {Promise<void>}
  */
-// `res` (the captured response from renderJSON) is passed in so the post-
-// await throwError below does not dereference a nulled `local.res`. Pre-
-// await reads of `local.req`/`local.res` (lines 31-86) are part of
-// renderJSON's synchronous call (it is not async), so they are safe — the
-// race window opens only after `await fs.promises.writeFile` at line 100.
-async function writeCache(bundle, opt, jsonContent, res) {
+// Every render-scoped value is threaded as a parameter — writeCache is
+// module-level and must not read the per-request bindings, which are
+// function-scoped inside renderJSON (#B63). The post-await throwError uses
+// the captured `res` so it never dereferences a nulled `local.res`, and the
+// captured `throwError` so a concurrent renderJSON entering during the
+// writeFile await can never re-route this request's error reporting.
+async function writeCache(bundle, opt, jsonContent, req, res, cacheIsEnabled, throwError) {
     if (
-        typeof(local.req.routing.cache) == 'undefined'
+        typeof(req.routing.cache) == 'undefined'
         ||
-        ! local.req.routing.cache
+        ! req.routing.cache
         ||
-        ! /^true$/i.test(self.serverInstance._cacheIsEnabled)
+        ! /^true$/i.test(cacheIsEnabled)
     ) {
         return;
     }
-    // before: "data:" + local.req.originalUrl  (#C3 — added bundle namespace to prevent silent collisions when two bundles serve the same URL path)
-    var cacheKey = "data:" + bundle + ":" + local.req.originalUrl;
-    var responseHeaders = local.res.getHeaders() || {};
+    // before: "data:" + originalUrl only  (#C3 — added bundle namespace to prevent silent collisions when two bundles serve the same URL path)
+    var cacheKey = "data:" + bundle + ":" + req.originalUrl;
+    var responseHeaders = res.getHeaders() || {};
 
     // Caching kinds are: `memory` & `fs`
-    var cachingOption = ( typeof(local.req.routing.cache) == 'string' ) ? { type: local.req.routing.cache } : JSON.clone(local.req.routing.cache);
+    var cachingOption = ( typeof(req.routing.cache) == 'string' ) ? { type: req.routing.cache } : JSON.clone(req.routing.cache);
     if ( typeof(cachingOption.ttl) == 'undefined' ) {
         cachingOption.ttl = opt.ttl
     }
@@ -88,7 +97,7 @@ async function writeCache(bundle, opt, jsonContent, res) {
     // - prioritize content linked to sessions
     // - default ttl is 3600 sec
     if ( /^fs$/i.test(cachingOption.type) ) {
-        var url = local.req.originalUrl;
+        var url = req.originalUrl;
         if ( /\/$/.test(url) ) {
             url += 'index'
         }
@@ -116,11 +125,11 @@ async function writeCache(bundle, opt, jsonContent, res) {
     // Invalidation
     if ( typeof(cachingOption.invalidateOnEvents) != 'undefined' ) {
         if ( !Array.isArray(cachingOption.invalidateOnEvents) ) {
-            // #M1 — post-await read goes through the captured `res` (passed
-            // from renderJSON) rather than `local.res`, which renderJSON may
-            // have nulled at its terminal exit between the writeFile await
-            // and this resume point.
-            return self.throwError(res, 500, new Error('cache.invalidateOn must be an array'));
+            // #M1/#B63 — this resume point sits after the writeFile await:
+            // both the response AND the reporting controller come from the
+            // threaded parameters (renderJSON's captures), never from the
+            // module scope a concurrent request may have moved on from.
+            return throwError(res, 500, new Error('cache.invalidateOn must be an array'));
         }
         // Placing event listeners
         cache.setEvents(cacheKey, cachingOption.invalidateOnEvents);
@@ -141,10 +150,12 @@ async function writeCache(bundle, opt, jsonContent, res) {
  * @returns {void}
  */
 module.exports = function renderJSON(jsonObj, deps) {
-    // Inherited from controller
-    self            = deps.self;
-    local           = deps.local;
-    headersSent     = deps.headersSent;
+    // Inherited from controller — function-scoped (#B63): a concurrent
+    // renderJSON must not reassign this render's captures while its
+    // fire-and-forget writeCache is suspended at the writeFile await.
+    var self            = deps.self;
+    var local           = deps.local;
+    var headersSent     = deps.headersSent;
 
     // preventing multiple call of self.renderJSON() when controller is rendering from another required controller
     if (local.options.renderingStack.length > 1) {
@@ -165,7 +176,6 @@ module.exports = function renderJSON(jsonObj, deps) {
 
     // Using server cache to cache compiledTemplates
     cache.from(self.serverInstance._cached);
-    cachePath       = self.serverInstance._cachePath;
 
     var request     = local.req;
     var response    = local.res;
@@ -441,7 +451,7 @@ module.exports = function renderJSON(jsonObj, deps) {
             && typeof(request.routing.cache) != 'undefined'
             && /^GET$/i.test(request.method)
         ) {
-            writeCache(self._options.bundle, local.options.conf.server.cache, data, response).catch(function(err) {
+            writeCache(self._options.bundle, local.options.conf.server.cache, data, request, response, self.serverInstance._cacheIsEnabled, self.throwError).catch(function(err) {
                 console.error('[render-json] writeCache failed:', err);
             });
         }

package/framework/{v0.5.6 → v0.5.7}/core/controller/controller.render-stream.js

@@ -30,13 +30,18 @@
  * @param {object}        deps           Injected by controller: { self, local, headersSent }
  */
 
-var self, local, headersSent;
-
 module.exports = function renderStream(asyncIterable, contentType, deps) {
 
-    self        = deps.self;
-    local       = deps.local;
-    headersSent = deps.headersSent;
+    // #B62 (sibling of the render-swig #B61 race fix): the per-request deps
+    // are FUNCTION-scoped. In prod this module is a shared singleton across
+    // concurrent requests; with module-scoped captures, the fire-and-forget
+    // _doStream IIFE below resumed after its `for await` reading a CONCURRENT
+    // request's refs — its catch reported errors through the other request's
+    // controller, and its finally nulled the OTHER request's live
+    // local.req/res/next mid-stream (measured) while never releasing its own.
+    var self        = deps.self;
+    var local       = deps.local;
+    var headersSent = deps.headersSent;
 
     // Prevent double-render (same guard used by renderJSON / renderTEXT)
     if (local.options.renderingStack.length > 1) return false;

package/framework/{v0.5.6 → v0.5.7}/core/controller/controller.render-swig.js

@@ -13,17 +13,13 @@ var emitInspectorWindowData = require('./inspector-window-emit');
 var blacklistRe       = /[<>]/g;
 
 // Inherited from controller.
-// #INS10 race fix: `self` / `local` are NOT declared module-scoped — they are
-// captured FUNCTION-scoped inside render() (see the deps unpack) so concurrent
-// renders never share them. The refs below stay module-scoped (read pre-await).
-var getData             = null
-    , hasViews          = null
-    , setResources      = null
-    // Default filters
-    , SwigFilters       = null
-    , headersSent       = null
-    , cachePath         = null
-;
+// #B61 (completes the #INS10 race fix): ALL per-request deps are captured
+// FUNCTION-scoped inside render() — nothing per-request lives at module scope.
+// In prod this module is a shared singleton across concurrent requests, and a
+// module-scoped capture is reassigned by every incoming render; a render
+// suspended at an await would resume reading a CONCURRENT request's closures
+// (measured: the post-await setResources / getData calls executed the other
+// request's functions, gap-filling its page data into this render's context).
 
 /**
  * Write the rendered HTML to the cache store (memory or file system).
@@ -35,16 +31,21 @@ var getData             = null
  * @param {string} htmlContent - Compiled HTML string to cache
  * @param {object} req         - Per-request request captured by render() (function-scoped, race-safe)
  * @param {object} res         - Per-request response captured by render() (function-scoped, race-safe)
+ * @param {boolean|string} cacheIsEnabled - Server-level cache flag threaded by render(); writeCache
+ *                               is module-level and has no access to render()-scoped bindings
+ * @param {function} throwError - Render-scoped controller `throwError` (closure-bound), threaded
+ *                               for the `invalidateOnEvents` validation branch
  * @returns {Promise<void>}
  */
-async function writeCache(bundle, opt, htmlContent, req, res) {
+async function writeCache(bundle, opt, htmlContent, req, res, cacheIsEnabled, throwError) {
     if (
         typeof(req.routing.cache) == 'undefined'
         ||
         ! req.routing.cache
         ||
-        // replaced: /^true$/i.test() (#P6)
-        String(self.serverInstance._cacheIsEnabled).toLowerCase() !== 'true'
+        // replaced: /^true$/i.test() (#P6); flag threaded as a param — module scope
+        // has no render()-scoped bindings (see the #INS10 note at the top of this file)
+        String(cacheIsEnabled).toLowerCase() !== 'true'
     ) {
         return;
     }
@@ -124,7 +125,7 @@ async function writeCache(bundle, opt, htmlContent, req, res) {
         // Invalidation
         if ( typeof(cachingOption.invalidateOnEvents) != 'undefined' ) {
             if ( !Array.isArray(cachingOption.invalidateOnEvents) ) {
-                return self.throwError(res, 500, new Error('cache.invalidateOn must be an array'));
+                return throwError(res, 500, new Error('cache.invalidateOn must be an array'));
             }
             // Placing event listeners
             cache.setEvents(cacheKey, cachingOption.invalidateOnEvents);
@@ -162,23 +163,28 @@ async function writeCache(bundle, opt, htmlContent, req, res) {
 module.exports = async function render(userData, displayInspector, errOptions, deps) {
 
     // Inherited from controller.
-    // #INS10 race fix — `self` / `local` are FUNCTION-scoped (`var`), not module-
-    // scoped: render() is async, so a render suspended at an await must not have
-    // its `self` / `local` overwritten by a concurrent render — otherwise the
-    // post-await Inspector emit (prod-window egress + dev `inspector#data`) would
-    // carry the other request's `_queryLog` / `_timeline`. Mirrors render-nunjucks.js.
-    // (getData / hasViews / SwigFilters / headersSent stay module-scoped: read
-    //  before the first await, so they are not the documented race vector.)
+    // #INS10 / #B61 race fix — EVERY per-request dep is FUNCTION-scoped (`var`):
+    // render() is async, so a render suspended at an await must not have its
+    // captures overwritten by a concurrent render. #INS10 (8674c514) scoped
+    // `self` / `local` for the post-await Inspector emit; #B61 completes the
+    // sweep — getData / setResources were still module-scoped yet are read
+    // AFTER the template-read await (the setResources call and the
+    // `merge(data, getData())` restore further down), so a concurrent render's
+    // reassignment executed the OTHER request's closures and gap-filled its
+    // page data into this render. cachePath is likewise read post-await on the
+    // layout-cache path, and the engine ref was assigned as an implicit global.
     var self            = deps.self;
     var local           = deps.local;
-    getData         = deps.getData;
-    hasViews        = deps.hasViews;
-    setResources    = deps.setResources;
+    var getData         = deps.getData;
+    var hasViews        = deps.hasViews;
+    var setResources    = deps.setResources;
     // Default filters
-    swig            = deps.swig;
-    SwigFilters     = deps.SwigFilters;
-    headersSent     = deps.headersSent;
-;
+    var swig            = deps.swig;
+    var SwigFilters     = deps.SwigFilters;
+    var headersSent     = deps.headersSent;
+    // Assigned on the layout-cache path once localOptions is resolved; read
+    // post-await there (.gitignore drop + the {% extends %} rewrite).
+    var cachePath       = null;
     // Function-scoped captures of per-request refs. The exported render()
     // is async with multiple await boundaries (template + layout reads,
     // cache writes). Between yields, `local.req` / `local.res` / `local.next`
@@ -977,7 +983,7 @@ module.exports = async function render(userData, displayInspector, errOptions, d
                     && typeof(req.routing.cache) != 'undefined'
                     && req.method.toUpperCase() === 'GET'
                 ) {
-                    await writeCache(localOptions.bundle, localOptions.conf.server.cache, htmlContent, req, res);
+                    await writeCache(localOptions.bundle, localOptions.conf.server.cache, htmlContent, req, res, self.serverInstance._cacheIsEnabled, self.throwError);
                 }
 
                 // Cache-Control: miss path — inform browsers/CDNs of the response lifetime (#C6)
@@ -1742,7 +1748,7 @@ module.exports = async function render(userData, displayInspector, errOptions, d
                         && req.method.toUpperCase() === 'GET'
                     )
                 ) {
-                    await writeCache(localOptions.bundle, localOptions.conf.server.cache, htmlContent, req, res);
+                    await writeCache(localOptions.bundle, localOptions.conf.server.cache, htmlContent, req, res, self.serverInstance._cacheIsEnabled, self.throwError);
                 }
 
                 // Cache-Control: miss path — inform browsers/CDNs of the response lifetime (#C6)

package/framework/{v0.5.6 → v0.5.7}/core/gna.js

@@ -1421,16 +1421,36 @@ isBundleMounted(projects, bundlesPath, getContext('bundle'), function onBundleMo
                                     var _jobsConf    = (_jobsAppConf && _jobsAppConf.jobs && typeof _jobsAppConf.jobs === 'object')
                                         ? _jobsAppConf.jobs
                                         : {};
-                                    lib.job.start({
+                                    var _jobsStartOpts = {
                                         maxConcurrency: _jobsConf.maxConcurrency,
                                         ttl:            _jobsConf.ttl,
                                         sweepInterval:  _jobsConf.sweepInterval,
                                         idSize:         _jobsConf.idSize,
+                                        retryBackoffMs: _jobsConf.retryBackoffMs,
                                         webhookMaxAttempts: _jobsConf.webhookMaxAttempts,
                                         webhookBackoffMs:   _jobsConf.webhookBackoffMs,
                                         webhookTimeoutMs:   _jobsConf.webhookTimeoutMs,
                                         webhookSecret:      _jobsConf.webhookSecret
-                                    });
+                                    };
+                                    // #AI6 connector-backed store — `jobs.store` names a
+                                    // connectors.json entry, resolved through lib/job-store.
+                                    // Fail-fast when the configured store cannot be built
+                                    // (#B57 shape): the config explicitly asked for durable
+                                    // records, so a silent memory fallback would hide the
+                                    // misconfig and lose the durability it asked for. An
+                                    // ABSENT `jobs.store` key still means the memory store.
+                                    if (typeof _jobsConf.store === 'string' && _jobsConf.store.length > 0) {
+                                        try {
+                                            _jobsStartOpts.store = lib.JobStore(_jobsConf.store);
+                                        } catch (jobsStoreErr) {
+                                            var _jobsStoreMsg = '[lib.job] jobs.store `' + _jobsConf.store + '` could not be built — aborting boot: ' + (jobsStoreErr.message || jobsStoreErr);
+                                            console.emerg(_jobsStoreMsg + '\n' + (jobsStoreErr.stack || ''));
+                                            // process.exit() truncates async stdio on a pipe — flush synchronously first.
+                                            fs.writeSync(2, _jobsStoreMsg + '\n');
+                                            process.exit(1);
+                                        }
+                                    }
+                                    lib.job.start(_jobsStartOpts);
                                 } catch (jobsErr) {
                                     console.warn('[lib.job] init skipped: ' + (jobsErr.message || jobsErr));
                                 }