ghost 6.57.1 → 6.58.0

package/core/frontend/services/llms/service.js

@@ -22,10 +22,10 @@ const LLMS_FULL_TXT_RECENT_POSTS_FOOTER = '\n_Includes the latest 500 public pos
 // Narrow field lists stop the content API selecting every column (e.g. the full
 // html of every post). The requested `formats` columns are appended to the
 // select by the input serializer, and `url` is resolved at serialization time.
-const LLMS_TXT_FIELDS = 'id,title,slug,custom_excerpt,featured,published_at,url';
+const LLMS_TXT_FIELDS = 'id,title,slug,custom_excerpt,featured,published_at,url,visibility';
 const LLMS_FULL_TXT_FIELDS = 'id,title,slug,featured,published_at,updated_at,created_at,url,visibility,custom_excerpt';
 
-function createLlmsService({settingsCache, labs, config, urlUtils, routing, api, fullTxtBudget}) {
+function createLlmsService({settingsCache, config, urlUtils, routing, api, machinePaymentsService, fullTxtBudget}) {
     const footerBudget = Math.max(
         Buffer.byteLength(LLMS_FULL_TXT_TRUNCATION_FOOTER, 'utf8'),
         Buffer.byteLength(LLMS_FULL_TXT_RECENT_POSTS_FOOTER, 'utf8')
@@ -33,7 +33,26 @@ function createLlmsService({settingsCache, labs, config, urlUtils, routing, api,
     const BUDGET = (fullTxtBudget || LLMS_FULL_TXT_BUDGET) - footerBudget;
 
     function isEnabled() {
-        return labs.isSet('llmsTxt') && !settingsCache.get('is_private') && settingsCache.get('llms_enabled') !== false;
+        return !settingsCache.get('is_private') && settingsCache.get('llms_enabled') !== false;
+    }
+
+    function isDiscoverable(entry) {
+        const {isPurchasableEntry} = require('../../../shared/machine-payments');
+
+        if (entry.visibility === 'public' || !entry.visibility) {
+            return true;
+        }
+
+        // Free-members-only stays undiscoverable for agents.
+        if (entry.visibility === 'members') {
+            return false;
+        }
+
+        if (!isPurchasableEntry(entry)) {
+            return false;
+        }
+
+        return machinePaymentsService?.isEnabled?.() === true;
     }
 
     async function fetchPublicEntry(resourceType, id, member = null) {
@@ -42,7 +61,7 @@ function createLlmsService({settingsCache, labs, config, urlUtils, routing, api,
         const response = await controller.read({
             id,
             formats: 'html',
-            include: 'authors,tags',
+            include: 'authors,tags,tiers',
             context: {member}
         });
 
@@ -288,13 +307,15 @@ function createLlmsService({settingsCache, labs, config, urlUtils, routing, api,
 
         const response = await controller.browse({
             ...options,
+            include: options.include || 'tiers',
             context: {member: null},
             filter: 'status:published',
-            ...(type === 'page' ? {order: 'id asc'} : {})
+            ...(type === 'page' ? {order: 'id asc'} : {order: 'published_at desc'})
         });
 
         const entries = (response?.[responseKey] || [])
-            .filter(entry => entry.url && !entry.url.endsWith('/404/'));
+            .filter(entry => entry.url && !entry.url.endsWith('/404/'))
+            .filter(isDiscoverable);
 
         return {entries, pagination: response?.meta?.pagination};
     }

package/core/frontend/services/proxy.js

@@ -79,6 +79,7 @@ module.exports = {
     // Settings helpers for calculated settings
     settingsHelpers: {
         isWebAnalyticsEnabled: settingsHelpers.isWebAnalyticsEnabled.bind(settingsHelpers),
+        isStripeConnected: (...args) => settingsHelpers.isStripeConnected(...args),
         // Delegates at call time (not bound at load) so tests that stub the
         // method on the settings-helpers service are still seen through here.
         getMembersValidationKey: (...args) => settingsHelpers.getMembersValidationKey(...args)

package/core/frontend/services/routing/api-adapter.js

@@ -9,9 +9,12 @@ exports.resolveResourceRead = resolveResourceRead;
 const lodash_1 = __importDefault(require("lodash"));
 const errors_1 = __importDefault(require("@tryghost/errors"));
 const config_1 = require("./config");
+// Without this, a domain resource with no entry here would only fail per request.
+config_1.QUERY;
 /**
- * Not every entry in QUERY is reachable from route data — `previews` and `email`
- * are internal routers with no `type`, so they resolve to no API call.
+ * A superset: `previews` and `email` are internal routers with no `type`, so
+ * nothing here resolves them — but the preview and email routers hand their
+ * QUERY entry straight to a controller, so removing one still breaks them.
  */
 const RESOURCE_CONFIGS = config_1.QUERY;
 /**
@@ -67,9 +70,12 @@ function resolveLongForm(entry) {
 /**
  * Resolve a single route data entry into a Content API call.
  *
- * This is the one place that knows how a domain `resource` maps onto a Ghost API
- * controller — routes.yaml talks about `tags`, the API is reached via
- * `tagsPublic`. Callers work with the domain model and never name a controller.
+ * Resolves how a domain `resource` maps onto a Ghost API controller — routes.yaml
+ * talks about `tags`, the API is reached via `tagsPublic`. Callers work with the
+ * domain model and never name a controller.
+ *
+ * Not the only such place yet: four routers still put a raw QUERY entry on
+ * `res.routerOptions.query` for their controllers to index directly.
  *
  * @example resolveApiCall('tag.food')
  *   // => {controller: 'tagsPublic', type: 'read', resource: 'tags', options: {slug: 'food', visibility: 'public'}}

package/core/frontend/services/routing/collection-router.js

@@ -138,8 +138,7 @@ class CollectionRouter extends ParentRouter {
      * @returns {string}
      */
     getResourceType() {
-        // @TODO: resourceAlias can be removed? We removed it. Looks like a last left over. Needs double checking.
-        return this.RESOURCE_CONFIG.resourceAlias || this.RESOURCE_CONFIG.resource;
+        return this.RESOURCE_CONFIG.resource;
     }
 
     /**

package/core/frontend/services/routing/controllers/entry/markdown.js

@@ -17,9 +17,37 @@ function llmsEnabled(req) {
     const llmsService = req.app.get('llmsService') || null;
     return Boolean(llmsService && llmsService.isEnabled());
 }
+function getMachinePaymentsService(req) {
+    return req.app.get('machinePaymentsService') || null;
+}
+function toFetchRequest(req) {
+    const protocol = req.protocol || 'http';
+    const host = req.get('host') || req.headers.host;
+    const url = new URL(req.originalUrl || req.url, `${protocol}://${host}`);
+    const headers = new Headers();
+    Object.entries(req.headers).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            headers.set(key, value.join(', '));
+        }
+        else if (value !== undefined) {
+            headers.set(key, String(value));
+        }
+    });
+    return new globalThis.Request(url.toString(), {
+        method: req.method || 'GET',
+        headers
+    });
+}
+async function copyFetchResponse(fetchResponse, res) {
+    res.status(fetchResponse.status);
+    fetchResponse.headers.forEach((value, key) => {
+        res.set(key, value);
+    });
+    return res.send(await fetchResponse.text());
+}
 /**
- * Only public entries ever render as markdown; gated entries stay html (or
- * 403 on an explicit `.md` URL).
+ * Only public entries ever render as markdown without payment; gated entries
+ * stay html (or 403 / 402 on an explicit `.md` URL).
  */
 function isPublic(entry) {
     return entry.visibility === 'public';
@@ -31,6 +59,33 @@ function serveMarkdown(res, entry) {
     res.type('text/markdown');
     return res.send(renderEntryMarkdown(entry, { llmsIndexUrl }));
 }
+function refuseMembersOnlyMarkdown(res) {
+    return res.status(403).type('text/markdown').send(MEMBERS_ONLY_MARKDOWN);
+}
+/**
+ * Challenge-before-render paid markdown path. Full HTML is loaded only after
+ * the machine-payments orchestrator verifies payment.
+ */
+async function servePaidMarkdown(req, res, entry) {
+    const machinePaymentsService = getMachinePaymentsService(req);
+    if (!machinePaymentsService?.isPurchasable(entry)) {
+        return refuseMembersOnlyMarkdown(res);
+    }
+    const resourceType = res.routerOptions.resourceType === 'pages' || res.routerOptions.context?.includes('page')
+        ? 'pages'
+        : 'posts';
+    const llmsIndexUrl = urlUtils.urlFor({ relativeUrl: '/llms.txt' }, true);
+    const contentLocation = getMarkdownPath(new URL(entry.url).pathname);
+    const fetchRequest = toFetchRequest(req);
+    const response = await machinePaymentsService.challengeOrFulfill(fetchRequest, {
+        entryId: entry.id,
+        resourceType,
+        description: typeof entry.title === 'string' ? entry.title : undefined,
+        contentLocation,
+        renderMarkdown: (paidEntry) => renderEntryMarkdown(paidEntry, { llmsIndexUrl })
+    });
+    return await copyFetchResponse(response, res);
+}
 /**
  * Whether this is a `.md` URL request (the scoped suffix route sets the flag).
  */
@@ -40,14 +95,17 @@ function isMdRequest(res) {
 /**
  * Serve a `.md` URL as markdown for LLM consumption. When the feature is
  * disabled we redirect to the canonical (html) url; members-only content is
- * refused.
+ * refused or challenged via machine payments when enabled.
  */
-function serveMdRequest(req, res, entry) {
+async function serveMdRequest(req, res, entry) {
     if (!llmsEnabled(req)) {
         return res.redirect(302, (0, canonical_url_1.default)(req, entry));
     }
     if (!isPublic(entry)) {
-        return res.status(403).type('text/markdown').send(MEMBERS_ONLY_MARKDOWN);
+        if (entry.visibility === 'paid' || entry.visibility === 'tiers') {
+            return await servePaidMarkdown(req, res, entry);
+        }
+        return refuseMembersOnlyMarkdown(res);
     }
     return serveMarkdown(res, entry);
 }

package/core/frontend/services/routing/controllers/entry.js

@@ -98,7 +98,7 @@ async function entryController(req, res, next) {
         // equal the entry's canonical (html) path, so the redirect would always
         // fire and 301 the request to html, losing the markdown intent.
         if (markdown.isMdRequest(res)) {
-            return markdown.serveMdRequest(req, res, entry);
+            return await markdown.serveMdRequest(req, res, entry);
         }
         if (isPermalinkStale(req, entry)) {
             debug('redirect');

package/core/frontend/services/routing/controllers/previews.js

@@ -38,9 +38,6 @@ module.exports = function previewController(req, res, next) {
                     return next();
                 }
 
-                // @TODO: we don't know which resource type it is, because it's a generic preview handler and the
-                //        preview API returns {previews: []}
-                // @TODO: figure out how to solve better
                 const resourceType = post.type;
 
                 // CASE: last param of the url is /edit, redirect to admin

package/core/frontend/services/routing/events.js

@@ -1,7 +1,8 @@
 const EventEmitter = require('events').EventEmitter;
 
 /**
- * Raised for each router mounted during activation.
+ * Raised by the four routers given a routerCreated callback: static routes,
+ * collections, static pages and taxonomies.
  *
  * @typedef {Object} RouteRegistered
  * @property {string|null} path - route in domain notation, e.g. `/about/`.

package/core/frontend/services/routing/parent-router.js

@@ -10,7 +10,6 @@
 const debug = require('@tryghost/debug')('routing:parent-router');
 
 const express = require('../../../shared/express');
-const _ = require('lodash');
 const url = require('url');
 const security = require('@tryghost/security');
 const {resolveResourceRead} = require('./api-adapter');
@@ -144,27 +143,6 @@ class ParentRouter {
         this._router.get(path, controller);
     }
 
-    /**
-     * @description Unmount route.
-     *
-     * Not used at the moment, but useful to keep for e.g. deregister routes on runtime.
-     *
-     * @param {string} path
-     */
-    unmountRoute(path) {
-        let indexToRemove = null;
-
-        _.each(this._router.stack, (item, index) => {
-            if (item.path === path) {
-                indexToRemove = index;
-            }
-        });
-
-        if (indexToRemove !== null) {
-            this._router.stack.splice(indexToRemove, 1);
-        }
-    }
-
     /**
      * @description Very important function to get the actual express router, which satisfies express.
      * @returns {import('express').Router}

package/core/frontend/services/routing/router-manager.js

@@ -53,8 +53,8 @@ class RouterManager {
     }
 
     /**
-     * The `init` function will return the wrapped parent express router and will start creating all
-     * routers if you pass the option "start: true".
+     * The `init` function will return the wrapped parent express router, and will start creating
+     * all routers if you pass `routeSettings`.
      *
      * CASES:
      *   - if Ghost starts, it will first init the site app with the wrapper router and then call `start`

package/core/frontend/services/routing/static-pages-router.js

@@ -68,7 +68,6 @@ class StaticPagesRouter extends ParentRouter {
     _prepareContext(req, res, next) {
         res.routerOptions = {
             type: 'entry',
-            filter: this.filter,
             permalinks: this.permalinks.getValue({withUrlOptions: true}),
             resourceType: this.getResourceType(),
             query: this.RESOURCE_CONFIG,

package/core/frontend/services/sitemap/handler.js

@@ -26,10 +26,9 @@ module.exports = function handler(siteApp) {
         res.send(content);
     };
 
-    // The XML reads are async: with a lazy URL backend the manager builds
-    // its index on first read. Express 4 does not forward async handler
-    // rejections, so each body is fully wrapped — a failed build or render
-    // becomes an error response instead of a hung socket.
+    // Express 4 does not forward async handler rejections, so each body is
+    // fully wrapped — a failed index build or render becomes an error
+    // response instead of a hung socket.
     siteApp.get('/sitemap.xml', async function sitemapXML(req, res, next) {
         try {
             sendXml(res, await manager.getIndexXml());

package/core/frontend/services/sitemap/site-map-manager.js

@@ -67,8 +67,7 @@ class SiteMapManager {
             };
             this._routerEntries.push(entry);
             this.pages.addUrl(entry.url, entry.datum);
-            // A router registering after a build (routes reload re-registers
-            // them one macrotask after RoutesReset) must not leave a
+            // A router registering after a build must not leave a
             // zero-router index marked built — the CDN would pin it.
             this._invalidateIndex();
         });

package/core/frontend/services/theme-engine/i18n/i18n.js

@@ -46,10 +46,6 @@ class I18n {
         return 'en';
     }
 
-    supportedLocales() {
-        return [this.defaultLocale()];
-    }
-
     /**
      * Exporting the current locale (e.g. "en") to make it available for other files as well,
      * such as core/frontend/helpers/date.js and core/frontend/helpers/lang.js
@@ -92,8 +88,6 @@ class I18n {
      */
     init() {
         this._strings = this._loadStrings();
-
-        this._initializeIntl();
     }
 
     /**
@@ -228,33 +222,6 @@ class I18n {
         return msg;
     }
 
-    /**
-     * [Private] Setup i18n support:
-     *  - Polyfill node.js if it does not have Intl support or support for a particular locale
-     */
-    _initializeIntl() {
-        let hasBuiltInLocaleData;
-        let IntlPolyfill;
-
-        if (global.Intl) {
-            // Determine if the built-in `Intl` has the locale data we need.
-            hasBuiltInLocaleData = this.supportedLocales().every(function (locale) {
-                return Intl.NumberFormat.supportedLocalesOf(locale)[0] === locale &&
-                    Intl.DateTimeFormat.supportedLocalesOf(locale)[0] === locale;
-            });
-            if (!hasBuiltInLocaleData) {
-                // `Intl` exists, but it doesn't have the data we need, so load the
-                // polyfill and replace the constructors with need with the polyfill's.
-                IntlPolyfill = require('intl');
-                Intl.NumberFormat = IntlPolyfill.NumberFormat;
-                Intl.DateTimeFormat = IntlPolyfill.DateTimeFormat;
-            }
-        } else {
-            // No `Intl`, so use and load the polyfill.
-            global.Intl = require('intl');
-        }
-    }
-
     _handleUninitialisedError(key) {
         logging.warn(`i18n was used before it was initialised with key ${key}`);
         this.init();

package/core/frontend/web/middleware/llms-discovery.js

@@ -15,9 +15,9 @@ function appendHeaderValue(existingValue, newValue) {
     return raw.concat(newValue).join(', ');
 }
 
-function createLlmsDiscovery({settingsCache, labs}) {
+function createLlmsDiscovery({settingsCache}) {
     function isDiscoveryEnabled() {
-        return labs.isSet('llmsTxt') && !settingsCache.get('is_private') && settingsCache.get('llms_enabled') !== false;
+        return !settingsCache.get('is_private') && settingsCache.get('llms_enabled') !== false;
     }
 
     return function llmsDiscovery(req, res, next) {

package/core/frontend/web/routers/serve-public-file.js

@@ -102,6 +102,36 @@ function createPublicFileMiddleware(location, file, mime, maxAge, options = {})
     };
 }
 
+/**
+ * Card assets are assembled in memory from a build-time manifest, so there's no
+ * file on disk to read — see services/assets-minification/card-assets.js
+ *
+ * @param {'css'|'js'} type
+ * @param {string} mime
+ * @param {number} maxAge
+ */
+function createCardAssetMiddleware(type, mime, maxAge) {
+    return function serveCardAssetMiddleware(req, res, next) {
+        const bundle = cardAssets.getBundle(type);
+
+        if (!bundle) {
+            return next(new errors.NotFoundError({
+                message: tpl(messages.fileNotFound),
+                code: 'PUBLIC_FILE_NOT_FOUND',
+                property: `cards.min.${type}`
+            }));
+        }
+
+        res.writeHead(200, {
+            'Content-Type': mime,
+            'Content-Length': Buffer.byteLength(bundle.content),
+            ETag: `"${bundle.hash}"`,
+            'Cache-Control': `public, max-age=${maxAge}`
+        });
+        res.end(bundle.content);
+    };
+}
+
 // Handles requests to robots.txt and favicon.ico (and caches them)
 function servePublicFile(location, file, type, maxAge, options = {}) {
     const publicFileMiddleware = createPublicFileMiddleware(location, file, type, maxAge, options);
@@ -127,9 +157,9 @@ function servePublicFiles(siteApp) {
     // Traffic analytics tracking script
     siteApp.get('/public/ghost-stats.min.js', createPublicFileMiddleware('static', 'public/ghost-stats.min.js', 'application/javascript', config.get('caching:publicAssets:maxAge')));
 
-    // Card assets (built on the fly)
-    siteApp.get('/public/cards.min.css', cardAssets.serveMiddleware(), createPublicFileMiddleware('built', 'public/cards.min.css', 'text/css', config.get('caching:publicAssets:maxAge')));
-    siteApp.get('/public/cards.min.js', cardAssets.serveMiddleware(), createPublicFileMiddleware('built', 'public/cards.min.js', 'application/javascript', config.get('caching:publicAssets:maxAge')));
+    // Card assets (assembled in memory per active theme)
+    siteApp.get('/public/cards.min.css', createCardAssetMiddleware('css', 'text/css', config.get('caching:publicAssets:maxAge')));
+    siteApp.get('/public/cards.min.js', createCardAssetMiddleware('js', 'application/javascript', config.get('caching:publicAssets:maxAge')));
 
     // Comment counts
     siteApp.get('/public/comment-counts.min.js', createPublicFileMiddleware('static', 'public/comment-counts.min.js', 'application/javascript', config.get('caching:publicAssets:maxAge')));

package/core/frontend/web/site.js

@@ -69,23 +69,24 @@ module.exports = function setupSiteApp(routerConfig) {
     servePublicFiles(siteApp);
 
     const settingsCache = require('../../shared/settings-cache');
-    const labs = require('../../shared/labs');
     const routing = require('../services/routing');
     const {api} = require('../services/proxy');
     const {createLlmsService} = require('../services/llms/service');
     const {createLlmsHandler} = require('../services/llms/handler');
     const {createLlmsDiscovery} = require('./middleware/llms-discovery');
+    const machinePaymentsService = require('../../server/services/machine-payments');
 
     const llmsService = createLlmsService({
         settingsCache,
-        labs,
         config,
         urlUtils,
         routing,
-        api
+        api,
+        machinePaymentsService
     });
 
     siteApp.set('llmsService', llmsService);
+    siteApp.set('machinePaymentsService', machinePaymentsService);
 
     const llmsHandler = createLlmsHandler({
         llmsService,
@@ -93,7 +94,7 @@ module.exports = function setupSiteApp(routerConfig) {
         settingsCache
     });
 
-    siteApp.use(createLlmsDiscovery({settingsCache, labs}));
+    siteApp.use(createLlmsDiscovery({settingsCache}));
 
     // Serve site images using the storage adapter
     siteApp.use(STATIC_IMAGE_URL_PREFIX, mw.handleImageSizes, adapterManager.getAdapter('storage:images').serve());

package/core/server/adapters/jobs/InMemoryJobsBackend.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const fastq_1 = __importDefault(require("fastq"));
+const adapter_base_jobs_1 = require("@tryghost/adapter-base-jobs");
+const later = require('@breejs/later');
+const logging = require('@tryghost/logging');
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 10000;
+const DEFAULT_CONCURRENCY = 3;
+function hasSeconds(cron) {
+    return cron.trim().split(/\s+/).length >= 6;
+}
+function resolveConcurrency(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_CONCURRENCY;
+    }
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+        throw new errors_1.default.IncorrectUsageError({
+            message: `Invalid jobs backend concurrency: ${JSON.stringify(value)}. Expected a positive integer.`
+        });
+    }
+    return value;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+class InMemoryJobsBackend extends adapter_base_jobs_1.JobsBackendBase {
+    _processor;
+    _stopped;
+    _concurrency;
+    _queue;
+    _recurring;
+    constructor(config = {}) {
+        super();
+        this._processor = null;
+        this._stopped = false;
+        this._concurrency = resolveConcurrency(config.concurrency);
+        this._queue = this._createQueue();
+        this._recurring = new Map();
+    }
+    _createQueue() {
+        const queue = fastq_1.default.promise((envelope) => this._deliver(envelope), this._concurrency);
+        // Paused until start() attaches a processor; enqueue buffers meanwhile.
+        queue.pause();
+        return queue;
+    }
+    start({ processor }) {
+        this._processor = processor;
+        this._stopped = false;
+        this._queue.resume();
+    }
+    enqueue(envelope) {
+        if (this._stopped) {
+            return;
+        }
+        this._queue.push(envelope);
+    }
+    async _deliver(envelope) {
+        const processor = this._processor;
+        if (!processor) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: 'InMemoryJobsBackend attempted a delivery with no processor attached - the backend lifecycle is broken.'
+            });
+        }
+        try {
+            await processor(envelope);
+        }
+        catch (err) {
+            logging.error(`Job "${envelope.type}" delivery failed`, err);
+        }
+    }
+    scheduleRecurring(envelope, { cron }) {
+        // First schedule per type wins; a re-registration must not disturb a
+        // schedule that is already running (parity with a durable backend).
+        if (this._stopped || this._recurring.has(envelope.type)) {
+            return;
+        }
+        const parsed = later.parse.cron(cron, hasSeconds(cron));
+        const timer = later.setInterval(() => {
+            this.enqueue(envelope);
+        }, parsed);
+        this._recurring.set(envelope.type, timer);
+    }
+    _clearRecurring(type) {
+        const timer = this._recurring.get(type);
+        if (timer) {
+            timer.clear();
+            this._recurring.delete(type);
+        }
+    }
+    async shutdown(options = {}) {
+        const timeoutMs = options.timeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+        this._stopped = true;
+        for (const type of [...this._recurring.keys()]) {
+            this._clearRecurring(type);
+        }
+        const queue = this._queue;
+        queue.kill();
+        if (!queue.idle()) {
+            await Promise.race([queue.drained(), delay(timeoutMs)]);
+        }
+        // Fresh (paused) queue so a re-boot never inherits this lifecycle's
+        // abandoned in-flight deliveries against its concurrency limit.
+        this._queue = this._createQueue();
+        this._processor = null;
+    }
+}
+exports.default = InMemoryJobsBackend;