@abtnode/db-cache 1.17.8-beta-20260108-224855-28496abb → 1.17.8-beta-20260111-112953-aed5ff39

package/dist/index.mjs

@@ -21,20 +21,20 @@ function ulid() {
   return timeStr + rand;
 }
 
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 const _RedisAdapter = class _RedisAdapter {
   constructor() {
-    __publicField$4(this, "opts", null);
-    __publicField$4(this, "defaultTtl", 1e3 * 60 * 60);
-    __publicField$4(this, "url", "");
-    __publicField$4(this, "prefix", "");
-    __publicField$4(this, "prefixKey", (key) => `${this.prefix}:${key}`);
-    __publicField$4(this, "prefixKeyGroup", (key) => `${this.prefix}:group:${key}`);
+    __publicField$5(this, "opts", null);
+    __publicField$5(this, "defaultTtl", 1e3 * 60 * 60);
+    __publicField$5(this, "url", "");
+    __publicField$5(this, "prefix", "");
+    __publicField$5(this, "prefixKey", (key) => `${this.prefix}:${key}`);
+    __publicField$5(this, "prefixKeyGroup", (key) => `${this.prefix}:group:${key}`);
   }
   clearAll() {
     throw new Error("Method not implemented.");
@@ -177,10 +177,16 @@ const _RedisAdapter = class _RedisAdapter {
     const client = this.getClient();
     await client.flushAll();
   }
+  /**
+   * 获取 LRU 缓存统计信息（Redis 不使用 LRU 缓存）
+   */
+  getLruCacheStats() {
+    return null;
+  }
 };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-__publicField$4(_RedisAdapter, "clients", /* @__PURE__ */ new Map());
-__publicField$4(_RedisAdapter, "initPromises", /* @__PURE__ */ new Map());
+__publicField$5(_RedisAdapter, "clients", /* @__PURE__ */ new Map());
+__publicField$5(_RedisAdapter, "initPromises", /* @__PURE__ */ new Map());
 let RedisAdapter = _RedisAdapter;
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -209,6 +215,363 @@ async function withRetry(fn, {
   }
 }
 
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const lruCacheModule = require("lru-cache");
+const LRUCacheLib = lruCacheModule?.LRUCache || lruCacheModule?.default || lruCacheModule;
+const isTestEnv = process.env.NODE_ENV === "test";
+const eventHub = isTestEnv ? require("@arcblock/event-hub/single") : require("@arcblock/event-hub");
+const LRU_CACHE_SYNC_EVENT = "db-cache:lru:sync";
+const LRU_CACHE_DELETE_EVENT = "db-cache:lru:delete";
+const LRU_CACHE_CLEAR_EVENT = "db-cache:lru:clear";
+const shouldEnableSync = () => {
+  if (isTestEnv) {
+    return false;
+  }
+  return process.env.NODE_APP_INSTANCE !== void 0;
+};
+const _LruCache = class _LruCache {
+  constructor(options) {
+    __publicField$4(this, "cacheKey");
+    __publicField$4(this, "maxSize");
+    __publicField$4(this, "enableSync");
+    this.cacheKey = `lru:${options.prefix}`;
+    this.maxSize = options.maxSize ?? 1e4;
+    this.enableSync = (options.enableSync ?? true) && shouldEnableSync();
+    if (!_LruCache.caches.has(this.cacheKey)) {
+      _LruCache.caches.set(
+        this.cacheKey,
+        new LRUCacheLib({
+          max: this.maxSize,
+          ttl: 0
+          // 我们自己管理 TTL
+        })
+      );
+      _LruCache.groupCaches.set(this.cacheKey, /* @__PURE__ */ new Map());
+      if (this.enableSync && !_LruCache.listenerSetup.has(this.cacheKey)) {
+        this._setupSyncListener();
+        _LruCache.listenerSetup.set(this.cacheKey, true);
+      }
+    }
+  }
+  getCache() {
+    const cache = _LruCache.caches.get(this.cacheKey);
+    if (!cache) {
+      throw new Error("LRU cache not initialized");
+    }
+    return cache;
+  }
+  getGroupCaches() {
+    const groupCaches = _LruCache.groupCaches.get(this.cacheKey);
+    if (!groupCaches) {
+      throw new Error("LRU group cache not initialized");
+    }
+    return groupCaches;
+  }
+  getOrCreateGroupCache(key) {
+    const groupCaches = this.getGroupCaches();
+    if (!groupCaches.has(key)) {
+      groupCaches.set(
+        key,
+        new LRUCacheLib({
+          max: this.maxSize,
+          ttl: 0
+        })
+      );
+    }
+    return groupCaches.get(key);
+  }
+  /**
+   * 设置同步监听器，接收其他 worker 广播的缓存数据
+   */
+  _setupSyncListener() {
+    const { cacheKey, maxSize } = this;
+    eventHub.on(LRU_CACHE_SYNC_EVENT, (payload) => {
+      const { channel, key, value, expiresAt, isGroup, subKey } = payload;
+      if (channel !== cacheKey)
+        return;
+      const entry = { value, expiresAt };
+      if (isGroup && subKey !== void 0) {
+        const groupCaches = _LruCache.groupCaches.get(cacheKey);
+        if (groupCaches) {
+          const groupCache = groupCaches.get(key) || new LRUCacheLib({ max: maxSize, ttl: 0 });
+          groupCache.set(subKey, entry);
+          groupCaches.set(key, groupCache);
+        }
+      } else {
+        const cache = _LruCache.caches.get(cacheKey);
+        if (cache) {
+          cache.set(key, entry);
+        }
+      }
+    });
+    eventHub.on(LRU_CACHE_DELETE_EVENT, (payload) => {
+      const { channel, keys, isGroup, groupKey } = payload;
+      if (channel !== cacheKey)
+        return;
+      if (isGroup && groupKey !== void 0) {
+        const groupCaches = _LruCache.groupCaches.get(cacheKey);
+        if (groupCaches) {
+          const groupCache = groupCaches.get(groupKey);
+          if (groupCache) {
+            for (const key of keys) {
+              groupCache.delete(key);
+            }
+          }
+        }
+      } else {
+        const cache = _LruCache.caches.get(cacheKey);
+        if (cache) {
+          for (const key of keys) {
+            cache.delete(key);
+            const groupCaches = _LruCache.groupCaches.get(cacheKey);
+            if (groupCaches) {
+              groupCaches.delete(key);
+            }
+          }
+        }
+      }
+    });
+    eventHub.on(LRU_CACHE_CLEAR_EVENT, (payload) => {
+      const { channel } = payload;
+      if (channel !== cacheKey)
+        return;
+      const cache = _LruCache.caches.get(cacheKey);
+      if (cache) {
+        cache.clear();
+      }
+      const groupCaches = _LruCache.groupCaches.get(cacheKey);
+      if (groupCaches) {
+        groupCaches.clear();
+      }
+    });
+  }
+  /**
+   * 广播缓存数据给其他 worker
+   */
+  _broadcastSync(key, value, expiresAt, isGroup = false, subKey) {
+    if (this.enableSync) {
+      eventHub.broadcast(LRU_CACHE_SYNC_EVENT, {
+        channel: this.cacheKey,
+        key,
+        value,
+        expiresAt,
+        isGroup,
+        subKey
+      });
+    }
+  }
+  /**
+   * 广播删除缓存给其他 worker
+   */
+  _broadcastDelete(keys, isGroup = false, groupKey) {
+    if (this.enableSync && keys.length > 0) {
+      eventHub.broadcast(LRU_CACHE_DELETE_EVENT, {
+        channel: this.cacheKey,
+        keys,
+        isGroup,
+        groupKey
+      });
+    }
+  }
+  /**
+   * 广播清空缓存给其他 worker
+   */
+  _broadcastClear() {
+    if (this.enableSync) {
+      eventHub.broadcast(LRU_CACHE_CLEAR_EVENT, {
+        channel: this.cacheKey
+      });
+    }
+  }
+  isExpired(entry) {
+    if (!entry)
+      return true;
+    if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+      return true;
+    }
+    return false;
+  }
+  /* ---------------------- 基础 API ---------------------- */
+  /**
+   * 设置缓存
+   * @param key 缓存键
+   * @param value 序列化后的值
+   * @param expiresAt 过期时间戳，null 表示永不过期
+   */
+  set(key, value, expiresAt) {
+    const cache = this.getCache();
+    const entry = { value, expiresAt };
+    cache.set(key, entry);
+    this._broadcastSync(key, value, expiresAt);
+  }
+  /**
+   * 获取缓存
+   * @param key 缓存键
+   * @returns 序列化的值，未命中或过期返回 null
+   */
+  get(key) {
+    const cache = this.getCache();
+    const entry = cache.get(key);
+    if (!entry)
+      return null;
+    if (this.isExpired(entry)) {
+      cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  /**
+   * 检查缓存是否存在且未过期
+   */
+  has(key) {
+    const cache = this.getCache();
+    const entry = cache.get(key);
+    if (!entry)
+      return false;
+    if (this.isExpired(entry)) {
+      cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 删除缓存
+   */
+  del(key) {
+    const cache = this.getCache();
+    cache.delete(key);
+    const groupCaches = this.getGroupCaches();
+    groupCaches.delete(key);
+    this._broadcastDelete([key]);
+  }
+  /**
+   * 按前缀删除缓存
+   * @returns 删除的数量
+   */
+  delByPrefix(prefix) {
+    const cache = this.getCache();
+    const deletedKeys = [];
+    for (const key of cache.keys()) {
+      if (key.startsWith(prefix)) {
+        cache.delete(key);
+        deletedKeys.push(key);
+      }
+    }
+    const groupCaches = this.getGroupCaches();
+    for (const key of groupCaches.keys()) {
+      if (key.startsWith(prefix)) {
+        groupCaches.delete(key);
+      }
+    }
+    this._broadcastDelete(deletedKeys);
+    return deletedKeys.length;
+  }
+  /* ---------------------- 分组 API ---------------------- */
+  /**
+   * 设置分组缓存
+   */
+  groupSet(key, subKey, value, expiresAt) {
+    const groupCache = this.getOrCreateGroupCache(key);
+    const entry = { value, expiresAt };
+    groupCache.set(subKey, entry);
+    this._broadcastSync(key, value, expiresAt, true, subKey);
+  }
+  /**
+   * 获取分组缓存
+   */
+  groupGet(key, subKey) {
+    const groupCaches = this.getGroupCaches();
+    const groupCache = groupCaches.get(key);
+    if (!groupCache)
+      return null;
+    const entry = groupCache.get(subKey);
+    if (!entry)
+      return null;
+    if (this.isExpired(entry)) {
+      groupCache.delete(subKey);
+      return null;
+    }
+    return entry.value;
+  }
+  /**
+   * 检查分组缓存是否存在
+   */
+  groupHas(key, subKey) {
+    const groupCaches = this.getGroupCaches();
+    const groupCache = groupCaches.get(key);
+    if (!groupCache)
+      return false;
+    const entry = groupCache.get(subKey);
+    if (!entry)
+      return false;
+    if (this.isExpired(entry)) {
+      groupCache.delete(subKey);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 删除分组缓存
+   */
+  groupDel(key, subKey) {
+    const groupCaches = this.getGroupCaches();
+    const groupCache = groupCaches.get(key);
+    if (groupCache) {
+      groupCache.delete(subKey);
+      this._broadcastDelete([subKey], true, key);
+    }
+  }
+  /* ---------------------- 管理 API ---------------------- */
+  /**
+   * 清空所有缓存
+   */
+  clear() {
+    const cache = this.getCache();
+    cache.clear();
+    const groupCaches = this.getGroupCaches();
+    groupCaches.clear();
+    this._broadcastClear();
+  }
+  /**
+   * 获取缓存统计信息
+   */
+  getStats() {
+    const cache = this.getCache();
+    const groupCaches = this.getGroupCaches();
+    let totalGroupSize = 0;
+    for (const groupCache of groupCaches.values()) {
+      totalGroupSize += groupCache.size;
+    }
+    return {
+      size: cache.size,
+      // 普通缓存条目数
+      groupCount: totalGroupSize,
+      // 分组缓存条目数
+      maxSize: this.maxSize
+      // 最大容量
+    };
+  }
+  /**
+   * 关闭缓存（清理资源）
+   *
+   * 注意：不会广播 close 事件给其他 worker，因为每个 worker 有独立的生命周期
+   */
+  close() {
+    _LruCache.caches.delete(this.cacheKey);
+    _LruCache.groupCaches.delete(this.cacheKey);
+    _LruCache.listenerSetup.delete(this.cacheKey);
+  }
+};
+__publicField$4(_LruCache, "caches", /* @__PURE__ */ new Map());
+__publicField$4(_LruCache, "groupCaches", /* @__PURE__ */ new Map());
+__publicField$4(_LruCache, "listenerSetup", /* @__PURE__ */ new Map());
+let LruCache = _LruCache;
+
 var __defProp$3 = Object.defineProperty;
 var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$3 = (obj, key, value) => {
@@ -274,6 +637,8 @@ const _SqliteAdapter = class _SqliteAdapter {
     __publicField$3(this, "defaultTtl", 1e3 * 60 * 60);
     __publicField$3(this, "cleanupInterval", 5 * 60 * 1e3);
     __publicField$3(this, "dbPath", "");
+    __publicField$3(this, "enableLruCache", false);
+    __publicField$3(this, "lruCache", null);
   }
   /* ------------------------------- init ------------------------------- */
   async ensure() {
@@ -283,6 +648,28 @@ const _SqliteAdapter = class _SqliteAdapter {
       this.prefix = this.opts.prefix;
       this.defaultTtl = this.opts.ttl;
       this.cleanupInterval = this.opts.cleanupInterval ?? 5 * 60 * 1e3;
+      this.enableLruCache = this.opts.enableLruCache ?? false;
+    }
+    if (this.enableLruCache && !this.lruCache) {
+      const lruCacheKey = `sqlite:${this.dbPath}:${this.prefix}`;
+      if (!_SqliteAdapter.lruCaches.has(lruCacheKey)) {
+        const requestedSize = this.opts.lruMaxSize ?? 100;
+        const actualSize = Math.min(requestedSize, _SqliteAdapter.MAX_LRU_CACHE_SIZE);
+        if (requestedSize > _SqliteAdapter.MAX_LRU_CACHE_SIZE) {
+          console.warn(
+            `[SqliteAdapter] Requested LRU cache size ${requestedSize} exceeds maximum ${_SqliteAdapter.MAX_LRU_CACHE_SIZE}, using ${actualSize} instead`
+          );
+        }
+        _SqliteAdapter.lruCaches.set(
+          lruCacheKey,
+          new LruCache({
+            prefix: lruCacheKey,
+            maxSize: actualSize,
+            enableSync: this.opts.enableSync ?? true
+          })
+        );
+      }
+      this.lruCache = _SqliteAdapter.lruCaches.get(lruCacheKey);
     }
     if (_SqliteAdapter.clients.has(this.dbPath))
       return;
@@ -345,7 +732,11 @@ const _SqliteAdapter = class _SqliteAdapter {
     const storageKey = this.prefixKey(key);
     const effectiveTtl = opts.ttl !== void 0 ? opts.ttl : this.defaultTtl;
     const expiresAt = effectiveTtl > 0 ? Date.now() + effectiveTtl : null;
+    const serializedValue = this.serialize(value);
     if (opts.nx) {
+      if (this.lruCache?.has(storageKey)) {
+        return false;
+      }
       const existing = await dbGet(
         client,
         "SELECT value FROM kvcache WHERE key = ? AND subKey = ?",
@@ -364,13 +755,22 @@ const _SqliteAdapter = class _SqliteAdapter {
         value = excluded.value,
         expiresAt = excluded.expiresAt
     `,
-      [storageKey, "", this.serialize(value), expiresAt]
+      [storageKey, "", serializedValue, expiresAt]
     );
+    if (this.lruCache) {
+      this.lruCache.set(storageKey, serializedValue, expiresAt);
+    }
     return true;
   }
   async get(key) {
-    const client = this.getClient();
     const storageKey = this.prefixKey(key);
+    if (this.lruCache) {
+      const cached = this.lruCache.get(storageKey);
+      if (cached !== null) {
+        return this.deserialize(cached);
+      }
+    }
+    const client = this.getClient();
     const row = await dbGet(
       client,
       'SELECT value, "expiresAt" FROM kvcache WHERE key = ? AND subKey = ?',
@@ -382,16 +782,25 @@ const _SqliteAdapter = class _SqliteAdapter {
       await this.del(key);
       return null;
     }
+    if (this.lruCache) {
+      this.lruCache.set(storageKey, row.value, row.expiresAt);
+    }
     return this.deserialize(row.value);
   }
   async del(key) {
-    const client = this.getClient();
     const storageKey = this.prefixKey(key);
+    if (this.lruCache) {
+      this.lruCache.del(storageKey);
+    }
+    const client = this.getClient();
     await dbRun(client, "DELETE FROM kvcache WHERE key = ?", [storageKey]);
   }
   async has(key) {
-    const client = this.getClient();
     const storageKey = this.prefixKey(key);
+    if (this.lruCache?.has(storageKey)) {
+      return true;
+    }
+    const client = this.getClient();
     const row = await dbGet(
       client,
       'SELECT "expiresAt" FROM kvcache WHERE key = ? AND subKey = ?',
@@ -411,11 +820,7 @@ const _SqliteAdapter = class _SqliteAdapter {
     const storageKey = this.prefixKey(key);
     const effectiveTtl = opts.ttl !== void 0 ? opts.ttl : this.defaultTtl;
     const expiresAt = effectiveTtl > 0 ? Date.now() + effectiveTtl : null;
-    if (opts.nx) {
-      const exists = await this.groupHas(key, subKey);
-      if (exists)
-        return;
-    }
+    const serializedValue = this.serialize(value);
     await dbRun(
       client,
       `
@@ -425,12 +830,21 @@ const _SqliteAdapter = class _SqliteAdapter {
           value = excluded.value,
           expiresAt = excluded.expiresAt
       `,
-      [storageKey, subKey, this.serialize(value), expiresAt]
+      [storageKey, subKey, serializedValue, expiresAt]
     );
+    if (this.lruCache) {
+      this.lruCache.groupSet(storageKey, subKey, serializedValue, expiresAt);
+    }
   }
   async groupGet(key, subKey) {
-    const client = this.getClient();
     const storageKey = this.prefixKey(key);
+    if (this.lruCache) {
+      const cached = this.lruCache.groupGet(storageKey, subKey);
+      if (cached !== null) {
+        return this.deserialize(cached);
+      }
+    }
+    const client = this.getClient();
     const row = await dbGet(
       client,
       'SELECT value, "expiresAt" FROM kvcache WHERE key = ? AND subKey = ?',
@@ -442,11 +856,17 @@ const _SqliteAdapter = class _SqliteAdapter {
       await this.groupDel(key, subKey);
       return null;
     }
+    if (this.lruCache) {
+      this.lruCache.groupSet(storageKey, subKey, row.value, row.expiresAt);
+    }
     return this.deserialize(row.value);
   }
   async groupHas(key, subKey) {
-    const client = this.getClient();
     const storageKey = this.prefixKey(key);
+    if (this.lruCache?.groupHas(storageKey, subKey)) {
+      return true;
+    }
+    const client = this.getClient();
     const row = await dbGet(
       client,
       'SELECT "expiresAt" FROM kvcache WHERE key = ? AND subKey = ?',
@@ -461,12 +881,21 @@ const _SqliteAdapter = class _SqliteAdapter {
     return true;
   }
   async groupDel(key, subKey) {
-    const client = this.getClient();
     const storageKey = this.prefixKey(key);
+    if (this.lruCache) {
+      this.lruCache.groupDel(storageKey, subKey);
+    }
+    const client = this.getClient();
     await dbRun(client, "DELETE FROM kvcache WHERE key = ? AND subKey = ?", [storageKey, subKey]);
   }
   /* ------------------------------- misc ------------------------------- */
   async close() {
+    if (this.lruCache) {
+      this.lruCache.close();
+      const lruCacheKey = `sqlite:${this.dbPath}:${this.prefix}`;
+      _SqliteAdapter.lruCaches.delete(lruCacheKey);
+      this.lruCache = null;
+    }
     if (this.dbPath) {
       const timer = _SqliteAdapter.cleanupTimers.get(this.dbPath);
       if (timer) {
@@ -482,14 +911,29 @@ const _SqliteAdapter = class _SqliteAdapter {
     }
   }
   async flushAll() {
+    if (this.lruCache) {
+      this.lruCache.clear();
+    }
     const client = this.getClient();
     const run = promisify(client.run.bind(client));
     await run("DELETE FROM kvcache");
   }
+  /**
+   * 获取 LRU 缓存统计信息
+   */
+  getLruCacheStats() {
+    if (!this.lruCache) {
+      return null;
+    }
+    return this.lruCache.getStats();
+  }
 };
 __publicField$3(_SqliteAdapter, "clients", /* @__PURE__ */ new Map());
 __publicField$3(_SqliteAdapter, "initPromises", /* @__PURE__ */ new Map());
 __publicField$3(_SqliteAdapter, "cleanupTimers", /* @__PURE__ */ new Map());
+__publicField$3(_SqliteAdapter, "lruCaches", /* @__PURE__ */ new Map());
+/** LRU 缓存的最大条数上限 */
+__publicField$3(_SqliteAdapter, "MAX_LRU_CACHE_SIZE", 100);
 let SqliteAdapter = _SqliteAdapter;
 
 var __defProp$2 = Object.defineProperty;
@@ -641,6 +1085,14 @@ class BaseDBCache {
     await this.adapter.ensure();
     return this.adapter.flushAll();
   }
+  /**
+   * 获取 LRU 缓存统计信息
+   * @returns 缓存统计信息，如果未启用 LRU 缓存则返回 null
+   */
+  getLruCacheStats() {
+    this.initAdapter();
+    return this.adapter.getLruCacheStats();
+  }
 }
 
 var __defProp$1 = Object.defineProperty;
@@ -851,4 +1303,4 @@ const getAbtNodeRedisAndSQLiteUrl = () => {
   return params;
 };
 
-export { LockDBCache as DBCache, getAbtNodeRedisAndSQLiteUrl, withRetry };
+export { LockDBCache as DBCache, LruCache, getAbtNodeRedisAndSQLiteUrl, withRetry };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abtnode/db-cache",
-  "version": "1.17.8-beta-20260108-224855-28496abb",
-  "description": "Db cache use redis or sqlite as backend",
+  "version": "1.17.8-beta-20260111-112953-aed5ff39",
+  "description": "Db cache use redis, sqlite or memory as backend",
   "publishConfig": {
     "access": "public"
   },
@@ -27,7 +27,9 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@arcblock/event-hub": "^1.28.4",
     "@types/proper-lockfile": "^4.1.4",
+    "lru-cache": "^11.1.0",
     "proper-lockfile": "^4.1.2",
     "redis": "^5.1.1",
     "sqlite3": "^5.1.7"
@@ -42,5 +44,5 @@
     "prettier": "^3.3.2",
     "unbuild": "^2.0.0"
   },
-  "gitHead": "e4407556f8c8f909afdfc6abc05228b0b495dcbf"
+  "gitHead": "b4c76fd49b8c98c9554c37c798f58ddf334fed4c"
 }