@speedkit/cli 4.15.0 → 4.16.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [4.16.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.15.1...v4.16.0) (2026-07-13)
+
+
+### Features
+
+* **onboarding:** refetch last 10 cached entries after fileChange ([779c6af](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/779c6af13e371af2b6d04621301921920139ca80))
+
+## [4.15.1](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.15.0...v4.15.1) (2026-07-08)
+
+
+### Bug Fixes
+
+* ignore page-examples.json for deployments ([209fec8](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/209fec89d17f7b6c34a5891fb761564cdcdad35c))
+
 # [4.15.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.14.0...v4.15.0) (2026-07-03)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.15.0 linux-x64 node-v22.23.1
+@speedkit/cli/4.16.0 linux-x64 node-v22.23.1
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND

package/dist/services/integration-api/file-reader.d.ts

@@ -5,13 +5,14 @@ export default class FileReader {
     private readonly basePath;
     private readonly whiteList;
     private readonly blockedFolders;
+    private readonly blockedFiles;
     allowedExtensions: string[];
     constructor(fileSystem: {
         readFileSync: (path: string, options: "utf-8") => string;
         readdirSync: (path: string, options: {
             withFileTypes: boolean;
         }) => Dirent[];
-    }, configName: string, basePath: string, whiteList?: string[], blockedFolders?: string[]);
+    }, configName: string, basePath: string, whiteList?: string[], blockedFolders?: string[], blockedFiles?: string[]);
     getFileList(basePath?: string): string[];
     getContent(path: string): Promise<string>;
     private isAllowedFolder;

package/dist/services/integration-api/file-reader.js

@@ -9,13 +9,15 @@ export default class FileReader {
     basePath;
     whiteList;
     blockedFolders;
+    blockedFiles;
     allowedExtensions = ["js", "es6", "json", "css"];
-    constructor(fileSystem, configName, basePath, whiteList = [], blockedFolders = []) {
+    constructor(fileSystem, configName, basePath, whiteList = [], blockedFolders = [], blockedFiles = []) {
         this.fileSystem = fileSystem;
         this.configName = configName;
         this.basePath = basePath;
         this.whiteList = whiteList;
         this.blockedFolders = blockedFolders;
+        this.blockedFiles = blockedFiles;
     }
     getFileList(basePath = this.basePath) {
         let files = [];
@@ -54,6 +56,8 @@ export default class FileReader {
     }
     isAllowedFile(fileName) {
         const extension = this.getFileExtension(fileName);
+        if (this.blockedFiles.some((file) => fileName.includes(file)))
+            return false;
         return (this.allowedExtensions.includes(extension) && this.isWhiteListed(fileName));
     }
     getFileExtension(fileName) {

package/dist/services/integration-api/integration-api-factory.js

@@ -38,7 +38,7 @@ export class IntegrationApiFactory {
     }
     getFileReader() {
         if (!this.fileReader) {
-            this.fileReader = new FileReader(fs, this.context.configName, this.context.basePath, this.context.whitelist, this.context.blockedFolders);
+            this.fileReader = new FileReader(fs, this.context.configName, this.context.basePath, this.context.whitelist, this.context.blockedFolders, this.context.blockedFiles);
         }
         return this.fileReader;
     }

package/dist/services/integration-api/integration-api-model.d.ts

@@ -100,11 +100,13 @@ export interface VirtualFileConfig {
     overrideLocalFile?: boolean;
 }
 export declare const DEFAULT_BLOCKED_FOLDERS: string[];
+export declare const DEFAULT_BLOCKED_FILES: string[];
 export declare class IntegrationApiContext {
     readonly basePath: string;
     readonly configName: string;
     readonly whitelist: string[];
     readonly blockedFolders: string[];
     readonly useTestConfig: boolean;
-    constructor(basePath: string, configName: string, whitelist?: string[], blockedFolders?: string[], useTestConfig?: boolean);
+    readonly blockedFiles: string[];
+    constructor(basePath: string, configName: string, whitelist?: string[], blockedFolders?: string[], useTestConfig?: boolean, blockedFiles?: string[]);
 }

package/dist/services/integration-api/integration-api-model.js

@@ -19,18 +19,27 @@ export var FILE_TYPE;
     FILE_TYPE["READONLY_FILE"] = "readonly";
     FILE_TYPE["CUSTOMER_FILE"] = "customer";
 })(FILE_TYPE || (FILE_TYPE = {}));
-export const DEFAULT_BLOCKED_FOLDERS = ["test", ".local", ".git", ".idea"];
+export const DEFAULT_BLOCKED_FOLDERS = [
+    "test",
+    ".local",
+    ".git",
+    ".idea",
+    "page-examples",
+];
+export const DEFAULT_BLOCKED_FILES = ["page-examples"];
 export class IntegrationApiContext {
     basePath;
     configName;
     whitelist;
     blockedFolders;
     useTestConfig;
-    constructor(basePath, configName, whitelist = [], blockedFolders = DEFAULT_BLOCKED_FOLDERS, useTestConfig = false) {
+    blockedFiles;
+    constructor(basePath, configName, whitelist = [], blockedFolders = DEFAULT_BLOCKED_FOLDERS, useTestConfig = false, blockedFiles = DEFAULT_BLOCKED_FILES) {
         this.basePath = basePath;
         this.configName = configName;
         this.whitelist = whitelist;
         this.blockedFolders = blockedFolders;
         this.useTestConfig = useTestConfig;
+        this.blockedFiles = blockedFiles;
     }
 }

package/dist/services/onboarding/browser/baqend-response.d.ts

@@ -7,6 +7,11 @@ export declare class BaqendResponse implements Partial<Protocol.Fetch.FulfillReq
     private readonly contentType;
     private readonly contentLength;
     constructor(body: string | Buffer, contentType?: string, headers?: Protocol.Fetch.HeaderEntry[], status?: number);
+    /**
+     * Epoch ms parsed from the `last-modified` header (set when the response was
+     * built), or 0 if absent/unparseable. Used to order cache entries by recency.
+     */
+    getLastModified(): number;
     setHeader(name: string, value: string): void;
     protected addCustomHeaders(headers?: Protocol.Fetch.HeaderEntry[]): Protocol.Fetch.HeaderEntry[];
 }

package/dist/services/onboarding/browser/baqend-response.js

@@ -23,6 +23,15 @@ export class BaqendResponse {
             ? body.toString("base64")
             : Buffer.from(body).toString("base64");
     }
+    /**
+     * Epoch ms parsed from the `last-modified` header (set when the response was
+     * built), or 0 if absent/unparseable. Used to order cache entries by recency.
+     */
+    getLastModified() {
+        const header = this.responseHeaders.find((h) => h.name.toLowerCase() === "last-modified");
+        const timestamp = header ? Date.parse(header.value) : NaN;
+        return Number.isNaN(timestamp) ? 0 : timestamp;
+    }
     setHeader(name, value) {
         for (const header of this.responseHeaders) {
             if (header.name === name) {

package/dist/services/onboarding/fetch-events/speed-kit-rum-pi-request.d.ts

@@ -1,21 +1,20 @@
 import { CDPSession } from "puppeteer";
 import { Protocol } from "puppeteer-core";
-import { CliService } from "../../cli/index.js";
 import { CustomerConfig } from "../../integration-api/index.js";
 import { AbortResponse } from "../browser/abort-response.js";
 import { FetchRequestPausedEventHandler } from "../onboarding-model.js";
-import { Cache } from "../request-cache/cache.js";
+import { VirtualOrestesApp } from "../virtual-orestes-app/index.js";
 /**
  * Intercepts v1/rum/pi requests,
- * if request contains changeDetection, clear dh-cache for respective url
+ * if request contains changeDetection, refresh dh-cache for respective url
+ * in the background
  *
  * @implements FetchRequestPausedEventHandler
  */
 export declare class SpeedKitRumPiRequest implements FetchRequestPausedEventHandler {
     private customerConfig;
-    private cache;
-    private cli;
+    private orestesApp;
     readonly patterns: Protocol.Fetch.RequestPattern[];
-    constructor(customerConfig: CustomerConfig, cache: Cache, cli: CliService);
+    constructor(customerConfig: CustomerConfig, orestesApp: VirtualOrestesApp);
     handle(event: Protocol.Fetch.RequestPausedEvent, _: CDPSession): Promise<AbortResponse | Partial<Protocol.Fetch.FulfillRequestRequest> | null>;
 }

package/dist/services/onboarding/fetch-events/speed-kit-rum-pi-request.js

@@ -1,19 +1,18 @@
 import { safe } from "../../../helpers/safe.js";
 /**
  * Intercepts v1/rum/pi requests,
- * if request contains changeDetection, clear dh-cache for respective url
+ * if request contains changeDetection, refresh dh-cache for respective url
+ * in the background
  *
  * @implements FetchRequestPausedEventHandler
  */
 export class SpeedKitRumPiRequest {
     customerConfig;
-    cache;
-    cli;
+    orestesApp;
     patterns;
-    constructor(customerConfig, cache, cli) {
+    constructor(customerConfig, orestesApp) {
         this.customerConfig = customerConfig;
-        this.cache = cache;
-        this.cli = cli;
+        this.orestesApp = orestesApp;
         this.patterns = [
             {
                 requestStage: "Request",
@@ -33,7 +32,7 @@ export class SpeedKitRumPiRequest {
             return;
         }
         const changeDetection = result.data.changeDetection;
-        this.cache.removeEntry(changeDetection.url);
-        this.cli.write(`changeDetection triggered for url: ${changeDetection.url} - cleared from dh-cache`);
+        // refresh in the background - do not block the intercepted rum/pi request
+        void this.orestesApp.refreshUrl(changeDetection.url);
     }
 }

package/dist/services/onboarding/file-events/file-watcher.d.ts

@@ -4,6 +4,7 @@ import { DocumentHandlerServer } from "../../document-handler-runtime/document-h
 import { Cache } from "../request-cache/cache.js";
 import { ConfigFileInterface, CustomerConfig, FileListInterface } from "../../integration-api/index.js";
 import { BrowserContext } from "../onboarding-model.js";
+import { VirtualOrestesApp } from "../virtual-orestes-app/index.js";
 /**
  * Add different callbacks that will be executed if a local file is changed.
  */
@@ -14,7 +15,18 @@ export declare class FileWatcher {
     private documentHandler;
     private browserContext;
     private cache;
+    private cacheRefresher?;
     constructor(cli: CliService, customerConfig: CustomerConfig, files: FileListInterface, documentHandler: DocumentHandlerServer, browserContext: BrowserContext, cache: Cache);
+    setCacheRefresher(cacheRefresher: VirtualOrestesApp): void;
+    /**
+     * Drop the dh-cache after a config change. When a cache refresher is wired
+     * (local mode) the most recent entries are re-warmed in the background so the
+     * developer's current pages stay instant and fresh; otherwise the cache is
+     * simply cleared.
+     *
+     * @private
+     */
+    private clearOrRefreshCache;
     /**
      * will perform various actions based on the changed file
      *

package/dist/services/onboarding/file-events/file-watcher.js

@@ -12,6 +12,9 @@ export class FileWatcher {
     documentHandler;
     browserContext;
     cache;
+    // Set in local mode (see OnboardingServiceFactory). When present, config
+    // changes re-warm the dh-cache in the background instead of just clearing it.
+    cacheRefresher;
     constructor(cli, customerConfig, files, documentHandler, browserContext, cache) {
         this.cli = cli;
         this.customerConfig = customerConfig;
@@ -20,6 +23,25 @@ export class FileWatcher {
         this.browserContext = browserContext;
         this.cache = cache;
     }
+    setCacheRefresher(cacheRefresher) {
+        this.cacheRefresher = cacheRefresher;
+    }
+    /**
+     * Drop the dh-cache after a config change. When a cache refresher is wired
+     * (local mode) the most recent entries are re-warmed in the background so the
+     * developer's current pages stay instant and fresh; otherwise the cache is
+     * simply cleared.
+     *
+     * @private
+     */
+    clearOrRefreshCache() {
+        if (this.cacheRefresher) {
+            // fire-and-forget: refresh clears the cache first, then re-warms
+            void this.cacheRefresher.refreshRecent(10);
+            return;
+        }
+        this.cache.clear();
+    }
     /**
      * will perform various actions based on the changed file
      *
@@ -157,7 +179,7 @@ export class FileWatcher {
         this.cli.writeWarning(`changed file: ${file.name}`);
         await this.safeClearPageBrowsersCacheStorage(page);
         await this.documentHandler.buildDocumentHandler();
-        this.cache.clear();
+        this.clearOrRefreshCache();
         await installResource.buildContent();
     }
     /**
@@ -170,7 +192,7 @@ export class FileWatcher {
     async onChangeDynamicStyleCallback(file, page) {
         this.cli.writeWarning(`changed file: ${file.name}`);
         await this.documentHandler.buildDocumentHandler();
-        this.cache.clear();
+        this.clearOrRefreshCache();
         const escapedStyles = encodeURI(file.getContent());
         const evaluateResult = await safe(race(Promise.all([
             page.evaluate(this.updateStylesInlineFunction, escapedStyles),

package/dist/services/onboarding/onboarding-service-factory.js

@@ -83,7 +83,7 @@ export class OnboardingServiceFactory {
         const fileWatcher = new FileWatcher(cli, customerConfig, files, documentHandler, browserContext, cache);
         const athenaClient = (await this.getAthenaClient(customerConfig.app)) || null;
         const messageHandler = await this.prepareMessagehandler(athenaClient, files, customerConfig);
-        const fetchHandler = await this.getFetchEventHandler(files, customerConfig, documentHandler, cache, cli, browserContext, athenaClient, messageHandler);
+        const fetchHandler = await this.getFetchEventHandler(files, customerConfig, documentHandler, cache, cli, browserContext, athenaClient, messageHandler, fileWatcher);
         const extensionBridge = new ExtensionBridge(cli);
         return new OnboardingService(browserContext, customerConfig, fetchHandler, fileWatcher, cli, messageHandler, extensionBridge);
     }
@@ -145,7 +145,7 @@ export class OnboardingServiceFactory {
         const configApiContext = new ConfigApiContext(app);
         return new ConfigApiServiceFactory(configApiContext).getService();
     }
-    async getFetchEventHandler(files, customerConfig, documentHandler, cache, cli, browserContext, athenaClient, messageHandler) {
+    async getFetchEventHandler(files, customerConfig, documentHandler, cache, cli, browserContext, athenaClient, messageHandler, fileWatcher) {
         const configApi = this.getConfigApi(customerConfig.app);
         const serverConfig = await this.getSpeedKitServerConfig(configApi, cli);
         const agent = this.getCrawlerAgent(customerConfig, cli);
@@ -167,7 +167,9 @@ export class OnboardingServiceFactory {
         ];
         if (this.context.local) {
             const orestesApp = new VirtualOrestesApp(customerConfig, crawler, documentHandler, cache, cli, messageHandler);
-            handlers.push(new SpeedKitAssetRequest(customerConfig, orestesApp), new SpeedKitRumPiRequest(customerConfig, cache, cli));
+            // let config-file changes re-warm the dh-cache in the background
+            fileWatcher.setCacheRefresher(orestesApp);
+            handlers.push(new SpeedKitAssetRequest(customerConfig, orestesApp), new SpeedKitRumPiRequest(customerConfig, orestesApp));
         }
         return new FetchEventHandler(handlers, customerConfig, cli, configApi);
     }

package/dist/services/onboarding/virtual-orestes-app/index.d.ts

@@ -16,6 +16,36 @@ export declare class VirtualOrestesApp {
     private localCacheErrors;
     constructor(customerConfig: CustomerConfig, crawler: Crawler, documentHandler: DocumentHandlerServer, cache: Cache, cli: CliService, developmentToolsMessages: DevtoolsExtensionApi);
     fetchAssetResponse(event: Protocol.Fetch.RequestPausedEvent): Promise<Partial<Protocol.Fetch.FulfillRequestRequest> | AbortResponse>;
+    /**
+     * Re-warm all cached entries for the given origin url in the background.
+     *
+     * Used when Speed Kit reports a changeDetection for a url: instead of just
+     * dropping the entry (which forces a cache-miss on the next request), we
+     * rebuild every cached variation of that url in place so the next request is
+     * an instant, fresh HIT. Fire-and-forget by design.
+     *
+     * @param originUrl the origin url reported by changeDetection
+     */
+    refreshUrl(originUrl: string): Promise<void>;
+    /**
+     * Clear the whole dh-cache, then re-warm the most recently cached entries in
+     * the background (ordered by their `last-modified` header). Used as a
+     * replacement for a bare cache clear on config changes: stale entries are
+     * dropped, but the last `limit` pages are rebuilt proactively so the
+     * developer's current pages stay instant and fresh.
+     *
+     * @param limit how many of the most recently cached entries to re-warm
+     */
+    refreshRecent(limit?: number): Promise<void>;
+    /**
+     * Rebuild a single cache entry (by its full asset request url), replacing the
+     * previously cached response. On failure the stale entry is dropped so we
+     * never keep serving outdated content.
+     *
+     * @param requestUrl the full asset request url used as the cache key
+     */
+    private refreshEntry;
+    private buildResponse;
     private getResponseText;
     private localCacheErrorKey;
     private recordLocalCacheError;

package/dist/services/onboarding/virtual-orestes-app/index.js

@@ -28,15 +28,78 @@ export class VirtualOrestesApp {
         this.developmentToolsMessages = developmentToolsMessages;
     }
     async fetchAssetResponse(event) {
-        const originUrl = this.getAssetUrl(event.request.url);
-        const UrlObject = new URL(event.request.url);
-        const variation = UrlObject.searchParams.has("bqvariation")
-            ? UrlObject.searchParams.get("bqvariation").trim()
-            : "default";
         const cachedResponse = this.getCachedResponse(event.request.url);
         if (cachedResponse instanceof BaqendResponse) {
             return cachedResponse;
         }
+        return this.buildResponse(event.request.url);
+    }
+    /**
+     * Re-warm all cached entries for the given origin url in the background.
+     *
+     * Used when Speed Kit reports a changeDetection for a url: instead of just
+     * dropping the entry (which forces a cache-miss on the next request), we
+     * rebuild every cached variation of that url in place so the next request is
+     * an instant, fresh HIT. Fire-and-forget by design.
+     *
+     * @param originUrl the origin url reported by changeDetection
+     */
+    async refreshUrl(originUrl) {
+        const matchingKeys = [...this.cache.getAll()]
+            .map(([key]) => key)
+            .filter((key) => key.includes(originUrl));
+        if (matchingKeys.length === 0) {
+            this.cli.write(`changeDetection for url: ${originUrl} - nothing cached to refresh`);
+            return;
+        }
+        this.cli.write(`changeDetection triggered for url: ${originUrl} - refreshing dh-cache in background`);
+        for (const key of matchingKeys) {
+            await this.refreshEntry(key);
+        }
+    }
+    /**
+     * Clear the whole dh-cache, then re-warm the most recently cached entries in
+     * the background (ordered by their `last-modified` header). Used as a
+     * replacement for a bare cache clear on config changes: stale entries are
+     * dropped, but the last `limit` pages are rebuilt proactively so the
+     * developer's current pages stay instant and fresh.
+     *
+     * @param limit how many of the most recently cached entries to re-warm
+     */
+    async refreshRecent(limit = 10) {
+        const recentKeys = [...this.cache.getAll()]
+            .sort(([, a], [, b]) => b.getLastModified() - a.getLastModified())
+            .slice(0, limit)
+            .map(([key]) => key);
+        this.cache.clear();
+        if (recentKeys.length === 0) {
+            return;
+        }
+        this.cli.write(`refreshing ${recentKeys.length} recent dh-cache entries in background`);
+        for (const key of recentKeys) {
+            await this.refreshEntry(key);
+        }
+    }
+    /**
+     * Rebuild a single cache entry (by its full asset request url), replacing the
+     * previously cached response. On failure the stale entry is dropped so we
+     * never keep serving outdated content.
+     *
+     * @param requestUrl the full asset request url used as the cache key
+     */
+    async refreshEntry(requestUrl) {
+        const result = await safe(this.buildResponse(requestUrl));
+        if (result.success === false) {
+            this.cache.removeEntry(requestUrl);
+            this.cli.writeError(`failed to refresh dh-cache entry ${requestUrl}: ${result.error}`);
+        }
+    }
+    async buildResponse(requestUrl) {
+        const originUrl = this.getAssetUrl(requestUrl);
+        const UrlObject = new URL(requestUrl);
+        const variation = UrlObject.searchParams.has("bqvariation")
+            ? UrlObject.searchParams.get("bqvariation").trim()
+            : "default";
         const response = await this.crawler.fetchRemote(originUrl, variation);
         // todo check if we can handle more then htmlResponses
         // only handle html responses
@@ -49,21 +112,21 @@ export class VirtualOrestesApp {
         const customHeaders = this.prepareCustomHeaders(originUrl, hasNoStoreFlag);
         // CDN Redirect
         if (originUrl !== response.url) {
-            return this.handleCdnRedirect(customHeaders, response, event);
+            return this.handleCdnRedirect(customHeaders, response, requestUrl);
         }
         if (response.status > 300 && response.status < 400) {
-            return this.returnRedirect(customHeaders, response, event);
+            return this.returnRedirect(customHeaders, response, requestUrl);
         }
         const { responseContent, textEncoding } = await this.getResponseText(response);
         if (!this.isHtmlContentHeader(response?.headers) ||
             !this.isValidHtmlContent(responseContent)) {
             const customResponse = new BaqendResponse(responseContent, `text/html; charset=${textEncoding}`, customHeaders);
-            this.cache.addEntry(event.request.url, customResponse);
+            this.cache.addEntry(requestUrl, customResponse);
             return customResponse;
         }
         const customResponse = await safe(this.documentHandler.transform(`text/html;charset=${textEncoding}`, responseContent, variation, originUrl, this.convertResponseHeadersToOrestesFormat(response)));
         if (customResponse.success === false) {
-            this.recordLocalCacheError(originUrl, event.request.url, variation, customResponse);
+            this.recordLocalCacheError(originUrl, requestUrl, variation, customResponse);
             return this.returnErrorResponse(customResponse, customHeaders);
         }
         this.clearLocalCacheError(originUrl, variation);
@@ -88,7 +151,7 @@ export class VirtualOrestesApp {
         const baqendResponse = new BaqendResponse(Buffer.isBuffer(skResponse.body)
             ? skResponse.body
             : iconv.encode(skResponse.body, textEncoding), skResponse.headers["content-type"] ?? `text/html;charset=${textEncoding}`, [...customHeaders, ...originHeaders]);
-        this.cache.addEntry(event.request.url, baqendResponse);
+        this.cache.addEntry(requestUrl, baqendResponse);
         return baqendResponse;
     }
     async getResponseText(response) {
@@ -159,16 +222,16 @@ export class VirtualOrestesApp {
         });
         return convertedResponseHeaders;
     }
-    returnRedirect(customHeaders, response, event) {
+    returnRedirect(customHeaders, response, requestUrl) {
         customHeaders.push({
             name: "location",
             value: response?.headers.get("location") || "",
         });
         const redirectResponse = new BaqendResponse("", null, customHeaders, response.status);
-        this.cache.addEntry(event.request.url, redirectResponse);
+        this.cache.addEntry(requestUrl, redirectResponse);
         return redirectResponse;
     }
-    handleCdnRedirect(customHeaders, response, event) {
+    handleCdnRedirect(customHeaders, response, requestUrl) {
         customHeaders.push({
             name: "x-debug-response-url",
             value: response.url,
@@ -181,7 +244,7 @@ export class VirtualOrestesApp {
         });
         serverTimingHeader.value += ",error;desc=202";
         const redirectResponse = new BaqendResponse("", null, customHeaders, 400);
-        this.cache.addEntry(event.request.url, redirectResponse);
+        this.cache.addEntry(requestUrl, redirectResponse);
         return redirectResponse;
     }
     getAssetUrl(requestUrl) {

package/oclif.manifest.json

@@ -847,5 +847,5 @@
       ]
     }
   },
-  "version": "4.15.0"
+  "version": "4.16.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@speedkit/cli",
   "description": "Speed Kit CLI",
-  "version": "4.15.0",
+  "version": "4.16.0",
   "author": {
     "name": "Baqend.com",
     "email": "info@baqend.com"