@upstash/ratelimit 2.0.1 → 2.0.3

package/dist/index.mjs

@@ -134,38 +134,181 @@ function ms(d) {
 }
 
 // src/hash.ts
-var setHash = async (ctx, script, kind) => {
-  const regionContexts = "redis" in ctx ? [ctx] : ctx.regionContexts;
-  const hashSample = regionContexts[0].scriptHashes[kind];
-  if (!hashSample) {
-    await Promise.all(regionContexts.map(async (context) => {
-      context.scriptHashes[kind] = await context.redis.scriptLoad(script);
-    }));
-  }
-  ;
-};
-var safeEval = async (ctx, script, kind, keys, args) => {
-  if (!ctx.cacheScripts) {
-    return await ctx.redis.eval(script, keys, args);
-  }
-  ;
-  await setHash(ctx, script, kind);
+var safeEval = async (ctx, script, keys, args) => {
   try {
-    return await ctx.redis.evalsha(ctx.scriptHashes[kind], keys, args);
+    return await ctx.redis.evalsha(script.hash, keys, args);
   } catch (error) {
     if (`${error}`.includes("NOSCRIPT")) {
-      console.log("Script with the expected hash was not found in redis db. It is probably flushed. Will load another scipt before continuing.");
-      ctx.scriptHashes[kind] = void 0;
-      await setHash(ctx, script, kind);
-      console.log("  New script successfully loaded.");
-      return await ctx.redis.evalsha(ctx.scriptHashes[kind], keys, args);
+      const hash = await ctx.redis.scriptLoad(script.script);
+      if (hash !== script.hash) {
+        console.warn(
+          "Upstash Ratelimit: Expected hash and the hash received from Redis are different. Ratelimit will work as usual but performance will be reduced."
+        );
+      }
+      return await ctx.redis.evalsha(hash, keys, args);
     }
     throw error;
   }
 };
 
-// src/lua-scripts/multi.ts
+// src/lua-scripts/single.ts
 var fixedWindowLimitScript = `
+  local key           = KEYS[1]
+  local window        = ARGV[1]
+  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
+
+  local r = redis.call("INCRBY", key, incrementBy)
+  if r == tonumber(incrementBy) then
+  -- The first time this key is set, the value will be equal to incrementBy.
+  -- So we only need the expire command once
+  redis.call("PEXPIRE", key, window)
+  end
+
+  return r
+`;
+var fixedWindowRemainingTokensScript = `
+      local key = KEYS[1]
+      local tokens = 0
+
+      local value = redis.call('GET', key)
+      if value then
+          tokens = value
+      end
+      return tokens
+    `;
+var slidingWindowLimitScript = `
+  local currentKey  = KEYS[1]           -- identifier including prefixes
+  local previousKey = KEYS[2]           -- key of the previous bucket
+  local tokens      = tonumber(ARGV[1]) -- tokens per window
+  local now         = ARGV[2]           -- current timestamp in milliseconds
+  local window      = ARGV[3]           -- interval in milliseconds
+  local incrementBy = ARGV[4]           -- increment rate per request at a given value, default is 1
+
+  local requestsInCurrentWindow = redis.call("GET", currentKey)
+  if requestsInCurrentWindow == false then
+    requestsInCurrentWindow = 0
+  end
+
+  local requestsInPreviousWindow = redis.call("GET", previousKey)
+  if requestsInPreviousWindow == false then
+    requestsInPreviousWindow = 0
+  end
+  local percentageInCurrent = ( now % window ) / window
+  -- weighted requests to consider from the previous window
+  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+  if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
+    return -1
+  end
+
+  local newValue = redis.call("INCRBY", currentKey, incrementBy)
+  if newValue == tonumber(incrementBy) then
+    -- The first time this key is set, the value will be equal to incrementBy.
+    -- So we only need the expire command once
+    redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
+  end
+  return tokens - ( newValue + requestsInPreviousWindow )
+`;
+var slidingWindowRemainingTokensScript = `
+  local currentKey  = KEYS[1]           -- identifier including prefixes
+  local previousKey = KEYS[2]           -- key of the previous bucket
+  local now         = ARGV[1]           -- current timestamp in milliseconds
+  local window      = ARGV[2]           -- interval in milliseconds
+
+  local requestsInCurrentWindow = redis.call("GET", currentKey)
+  if requestsInCurrentWindow == false then
+    requestsInCurrentWindow = 0
+  end
+
+  local requestsInPreviousWindow = redis.call("GET", previousKey)
+  if requestsInPreviousWindow == false then
+    requestsInPreviousWindow = 0
+  end
+
+  local percentageInCurrent = ( now % window ) / window
+  -- weighted requests to consider from the previous window
+  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+
+  return requestsInPreviousWindow + requestsInCurrentWindow
+`;
+var tokenBucketLimitScript = `
+  local key         = KEYS[1]           -- identifier including prefixes
+  local maxTokens   = tonumber(ARGV[1]) -- maximum number of tokens
+  local interval    = tonumber(ARGV[2]) -- size of the window in milliseconds
+  local refillRate  = tonumber(ARGV[3]) -- how many tokens are refilled after each interval
+  local now         = tonumber(ARGV[4]) -- current timestamp in milliseconds
+  local incrementBy = tonumber(ARGV[5]) -- how many tokens to consume, default is 1
+        
+  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
+        
+  local refilledAt
+  local tokens
+
+  if bucket[1] == false then
+    refilledAt = now
+    tokens = maxTokens
+  else
+    refilledAt = tonumber(bucket[1])
+    tokens = tonumber(bucket[2])
+  end
+        
+  if now >= refilledAt + interval then
+    local numRefills = math.floor((now - refilledAt) / interval)
+    tokens = math.min(maxTokens, tokens + numRefills * refillRate)
+
+    refilledAt = refilledAt + numRefills * interval
+  end
+
+  if tokens == 0 then
+    return {-1, refilledAt + interval}
+  end
+
+  local remaining = tokens - incrementBy
+  local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
+        
+  redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
+  redis.call("PEXPIRE", key, expireAt)
+  return {remaining, refilledAt + interval}
+`;
+var tokenBucketIdentifierNotFound = -1;
+var tokenBucketRemainingTokensScript = `
+  local key         = KEYS[1]
+  local maxTokens   = tonumber(ARGV[1])
+        
+  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
+
+  if bucket[1] == false then
+    return {maxTokens, ${tokenBucketIdentifierNotFound}}
+  end
+        
+  return {tonumber(bucket[2]), tonumber(bucket[1])}
+`;
+var cachedFixedWindowLimitScript = `
+  local key     = KEYS[1]
+  local window  = ARGV[1]
+  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
+
+  local r = redis.call("INCRBY", key, incrementBy)
+  if r == incrementBy then
+  -- The first time this key is set, the value will be equal to incrementBy.
+  -- So we only need the expire command once
+  redis.call("PEXPIRE", key, window)
+  end
+      
+  return r
+`;
+var cachedFixedWindowRemainingTokenScript = `
+  local key = KEYS[1]
+  local tokens = 0
+
+  local value = redis.call('GET', key)
+  if value then
+      tokens = value
+  end
+  return tokens
+`;
+
+// src/lua-scripts/multi.ts
+var fixedWindowLimitScript2 = `
 	local key           = KEYS[1]
 	local id            = ARGV[1]
 	local window        = ARGV[2]
@@ -181,7 +324,7 @@ var fixedWindowLimitScript = `
 
 	return fields
 `;
-var fixedWindowRemainingTokensScript = `
+var fixedWindowRemainingTokensScript2 = `
       local key = KEYS[1]
       local tokens = 0
 
@@ -189,7 +332,7 @@ var fixedWindowRemainingTokensScript = `
 
       return fields
     `;
-var slidingWindowLimitScript = `
+var slidingWindowLimitScript2 = `
 	local currentKey    = KEYS[1]           -- identifier including prefixes
 	local previousKey   = KEYS[2]           -- key of the previous bucket
 	local tokens        = tonumber(ARGV[1]) -- tokens per window
@@ -224,7 +367,7 @@ var slidingWindowLimitScript = `
 	end
 	return {currentFields, previousFields, true}
 `;
-var slidingWindowRemainingTokensScript = `
+var slidingWindowRemainingTokensScript2 = `
 	local currentKey    = KEYS[1]           -- identifier including prefixes
 	local previousKey   = KEYS[2]           -- key of the previous bucket
 	local now         	= ARGV[1]           -- current timestamp in milliseconds
@@ -273,6 +416,78 @@ var resetScript = `
       until cursor == "0"
     `;
 
+// src/lua-scripts/hash.ts
+var SCRIPTS = {
+  singleRegion: {
+    fixedWindow: {
+      limit: {
+        script: fixedWindowLimitScript,
+        hash: "b13943e359636db027ad280f1def143f02158c13"
+      },
+      getRemaining: {
+        script: fixedWindowRemainingTokensScript,
+        hash: "8c4c341934502aee132643ffbe58ead3450e5208"
+      }
+    },
+    slidingWindow: {
+      limit: {
+        script: slidingWindowLimitScript,
+        hash: "e1391e429b699c780eb0480350cd5b7280fd9213"
+      },
+      getRemaining: {
+        script: slidingWindowRemainingTokensScript,
+        hash: "65a73ac5a05bf9712903bc304b77268980c1c417"
+      }
+    },
+    tokenBucket: {
+      limit: {
+        script: tokenBucketLimitScript,
+        hash: "5bece90aeef8189a8cfd28995b479529e270b3c6"
+      },
+      getRemaining: {
+        script: tokenBucketRemainingTokensScript,
+        hash: "a15be2bb1db2a15f7c82db06146f9d08983900d0"
+      }
+    },
+    cachedFixedWindow: {
+      limit: {
+        script: cachedFixedWindowLimitScript,
+        hash: "c26b12703dd137939b9a69a3a9b18e906a2d940f"
+      },
+      getRemaining: {
+        script: cachedFixedWindowRemainingTokenScript,
+        hash: "8e8f222ccae68b595ee6e3f3bf2199629a62b91a"
+      }
+    }
+  },
+  multiRegion: {
+    fixedWindow: {
+      limit: {
+        script: fixedWindowLimitScript2,
+        hash: "a8c14f3835aa87bd70e5e2116081b81664abcf5c"
+      },
+      getRemaining: {
+        script: fixedWindowRemainingTokensScript2,
+        hash: "8ab8322d0ed5fe5ac8eb08f0c2e4557f1b4816fd"
+      }
+    },
+    slidingWindow: {
+      limit: {
+        script: slidingWindowLimitScript2,
+        hash: "cb4fdc2575056df7c6d422764df0de3a08d6753b"
+      },
+      getRemaining: {
+        script: slidingWindowRemainingTokensScript2,
+        hash: "558c9306b7ec54abb50747fe0b17e5d44bd24868"
+      }
+    }
+  }
+};
+var RESET_SCRIPT = {
+  script: resetScript,
+  hash: "54bd274ddc59fb3be0f42deee2f64322a10e2b50"
+};
+
 // src/types.ts
 var DenyListExtension = "denyList";
 var IpDenyListKey = "ipDenyList";
@@ -712,9 +927,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
       analytics: config.analytics,
       ctx: {
         regionContexts: config.redis.map((redis) => ({
-          redis,
-          scriptHashes: {},
-          cacheScripts: config.cacheScripts ?? true
+          redis
         })),
         cache: config.ephemeralCache ? new Cache(config.ephemeralCache) : void 0
       }
@@ -763,8 +976,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            fixedWindowLimitScript,
-            "limitHash",
+            SCRIPTS.multiRegion.fixedWindow.limit,
             [key],
             [requestId, windowDuration, incrementBy]
           )
@@ -839,8 +1051,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            fixedWindowRemainingTokensScript,
-            "getRemainingHash",
+            SCRIPTS.multiRegion.fixedWindow.getRemaining,
             [key],
             [null]
           )
@@ -866,8 +1077,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
         await Promise.all(ctx.regionContexts.map((regionContext) => {
           safeEval(
             regionContext,
-            resetScript,
-            "resetHash",
+            RESET_SCRIPT,
             [pattern],
             [null]
           );
@@ -920,8 +1130,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            slidingWindowLimitScript,
-            "limitHash",
+            SCRIPTS.multiRegion.slidingWindow.limit,
             [currentKey, previousKey],
             [tokens, now, windowDuration, requestId, incrementBy]
             // lua seems to return `1` for true and `null` for false
@@ -1010,8 +1219,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            slidingWindowRemainingTokensScript,
-            "getRemainingHash",
+            SCRIPTS.multiRegion.slidingWindow.getRemaining,
             [currentKey, previousKey],
             [now, windowSize]
             // lua seems to return `1` for true and `null` for false
@@ -1031,8 +1239,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
         await Promise.all(ctx.regionContexts.map((regionContext) => {
           safeEval(
             regionContext,
-            resetScript,
-            "resetHash",
+            RESET_SCRIPT,
             [pattern],
             [null]
           );
@@ -1042,162 +1249,6 @@ var MultiRegionRatelimit = class extends Ratelimit {
   }
 };
 
-// src/lua-scripts/single.ts
-var fixedWindowLimitScript2 = `
-  local key           = KEYS[1]
-  local window        = ARGV[1]
-  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
-
-  local r = redis.call("INCRBY", key, incrementBy)
-  if r == tonumber(incrementBy) then
-  -- The first time this key is set, the value will be equal to incrementBy.
-  -- So we only need the expire command once
-  redis.call("PEXPIRE", key, window)
-  end
-
-  return r
-`;
-var fixedWindowRemainingTokensScript2 = `
-      local key = KEYS[1]
-      local tokens = 0
-
-      local value = redis.call('GET', key)
-      if value then
-          tokens = value
-      end
-      return tokens
-    `;
-var slidingWindowLimitScript2 = `
-  local currentKey  = KEYS[1]           -- identifier including prefixes
-  local previousKey = KEYS[2]           -- key of the previous bucket
-  local tokens      = tonumber(ARGV[1]) -- tokens per window
-  local now         = ARGV[2]           -- current timestamp in milliseconds
-  local window      = ARGV[3]           -- interval in milliseconds
-  local incrementBy = ARGV[4]           -- increment rate per request at a given value, default is 1
-
-  local requestsInCurrentWindow = redis.call("GET", currentKey)
-  if requestsInCurrentWindow == false then
-    requestsInCurrentWindow = 0
-  end
-
-  local requestsInPreviousWindow = redis.call("GET", previousKey)
-  if requestsInPreviousWindow == false then
-    requestsInPreviousWindow = 0
-  end
-  local percentageInCurrent = ( now % window ) / window
-  -- weighted requests to consider from the previous window
-  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
-  if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
-    return -1
-  end
-
-  local newValue = redis.call("INCRBY", currentKey, incrementBy)
-  if newValue == tonumber(incrementBy) then
-    -- The first time this key is set, the value will be equal to incrementBy.
-    -- So we only need the expire command once
-    redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
-  end
-  return tokens - ( newValue + requestsInPreviousWindow )
-`;
-var slidingWindowRemainingTokensScript2 = `
-  local currentKey  = KEYS[1]           -- identifier including prefixes
-  local previousKey = KEYS[2]           -- key of the previous bucket
-  local now         = ARGV[1]           -- current timestamp in milliseconds
-  local window      = ARGV[2]           -- interval in milliseconds
-
-  local requestsInCurrentWindow = redis.call("GET", currentKey)
-  if requestsInCurrentWindow == false then
-    requestsInCurrentWindow = 0
-  end
-
-  local requestsInPreviousWindow = redis.call("GET", previousKey)
-  if requestsInPreviousWindow == false then
-    requestsInPreviousWindow = 0
-  end
-
-  local percentageInCurrent = ( now % window ) / window
-  -- weighted requests to consider from the previous window
-  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
-
-  return requestsInPreviousWindow + requestsInCurrentWindow
-`;
-var tokenBucketLimitScript = `
-  local key         = KEYS[1]           -- identifier including prefixes
-  local maxTokens   = tonumber(ARGV[1]) -- maximum number of tokens
-  local interval    = tonumber(ARGV[2]) -- size of the window in milliseconds
-  local refillRate  = tonumber(ARGV[3]) -- how many tokens are refilled after each interval
-  local now         = tonumber(ARGV[4]) -- current timestamp in milliseconds
-  local incrementBy = tonumber(ARGV[5]) -- how many tokens to consume, default is 1
-        
-  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
-        
-  local refilledAt
-  local tokens
-
-  if bucket[1] == false then
-    refilledAt = now
-    tokens = maxTokens
-  else
-    refilledAt = tonumber(bucket[1])
-    tokens = tonumber(bucket[2])
-  end
-        
-  if now >= refilledAt + interval then
-    local numRefills = math.floor((now - refilledAt) / interval)
-    tokens = math.min(maxTokens, tokens + numRefills * refillRate)
-
-    refilledAt = refilledAt + numRefills * interval
-  end
-
-  if tokens == 0 then
-    return {-1, refilledAt + interval}
-  end
-
-  local remaining = tokens - incrementBy
-  local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
-        
-  redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
-  redis.call("PEXPIRE", key, expireAt)
-  return {remaining, refilledAt + interval}
-`;
-var tokenBucketIdentifierNotFound = -1;
-var tokenBucketRemainingTokensScript = `
-  local key         = KEYS[1]
-  local maxTokens   = tonumber(ARGV[1])
-        
-  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
-
-  if bucket[1] == false then
-    return {maxTokens, ${tokenBucketIdentifierNotFound}}
-  end
-        
-  return {tonumber(bucket[2]), tonumber(bucket[1])}
-`;
-var cachedFixedWindowLimitScript = `
-  local key     = KEYS[1]
-  local window  = ARGV[1]
-  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
-
-  local r = redis.call("INCRBY", key, incrementBy)
-  if r == incrementBy then
-  -- The first time this key is set, the value will be equal to incrementBy.
-  -- So we only need the expire command once
-  redis.call("PEXPIRE", key, window)
-  end
-      
-  return r
-`;
-var cachedFixedWindowRemainingTokenScript = `
-  local key = KEYS[1]
-  local tokens = 0
-
-  local value = redis.call('GET', key)
-  if value then
-      tokens = value
-  end
-  return tokens
-`;
-
 // src/single.ts
 var RegionRatelimit = class extends Ratelimit {
   /**
@@ -1210,9 +1261,7 @@ var RegionRatelimit = class extends Ratelimit {
       timeout: config.timeout,
       analytics: config.analytics,
       ctx: {
-        redis: config.redis,
-        scriptHashes: {},
-        cacheScripts: config.cacheScripts ?? true
+        redis: config.redis
       },
       ephemeralCache: config.ephemeralCache,
       enableProtection: config.enableProtection,
@@ -1259,8 +1308,7 @@ var RegionRatelimit = class extends Ratelimit {
         const incrementBy = rate ? Math.max(1, rate) : 1;
         const usedTokensAfterUpdate = await safeEval(
           ctx,
-          fixedWindowLimitScript2,
-          "limitHash",
+          SCRIPTS.singleRegion.fixedWindow.limit,
           [key],
           [windowDuration, incrementBy]
         );
@@ -1283,8 +1331,7 @@ var RegionRatelimit = class extends Ratelimit {
         const key = [identifier, bucket].join(":");
         const usedTokens = await safeEval(
           ctx,
-          fixedWindowRemainingTokensScript2,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.fixedWindow.getRemaining,
           [key],
           [null]
         );
@@ -1300,8 +1347,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );
@@ -1349,8 +1395,7 @@ var RegionRatelimit = class extends Ratelimit {
         const incrementBy = rate ? Math.max(1, rate) : 1;
         const remainingTokens = await safeEval(
           ctx,
-          slidingWindowLimitScript2,
-          "limitHash",
+          SCRIPTS.singleRegion.slidingWindow.limit,
           [currentKey, previousKey],
           [tokens, now, windowSize, incrementBy]
         );
@@ -1375,8 +1420,7 @@ var RegionRatelimit = class extends Ratelimit {
         const previousKey = [identifier, previousWindow].join(":");
         const usedTokens = await safeEval(
           ctx,
-          slidingWindowRemainingTokensScript2,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.slidingWindow.getRemaining,
           [currentKey, previousKey],
           [now, windowSize]
         );
@@ -1392,8 +1436,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );
@@ -1434,8 +1477,7 @@ var RegionRatelimit = class extends Ratelimit {
         const incrementBy = rate ? Math.max(1, rate) : 1;
         const [remaining, reset] = await safeEval(
           ctx,
-          tokenBucketLimitScript,
-          "limitHash",
+          SCRIPTS.singleRegion.tokenBucket.limit,
           [identifier],
           [maxTokens, intervalDuration, refillRate, now, incrementBy]
         );
@@ -1454,8 +1496,7 @@ var RegionRatelimit = class extends Ratelimit {
       async getRemaining(ctx, identifier) {
         const [remainingTokens, refilledAt] = await safeEval(
           ctx,
-          tokenBucketRemainingTokensScript,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.tokenBucket.getRemaining,
           [identifier],
           [maxTokens]
         );
@@ -1473,8 +1514,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );
@@ -1522,8 +1562,7 @@ var RegionRatelimit = class extends Ratelimit {
           const success = cachedTokensAfterUpdate < tokens;
           const pending = success ? safeEval(
             ctx,
-            cachedFixedWindowLimitScript,
-            "limitHash",
+            SCRIPTS.singleRegion.cachedFixedWindow.limit,
             [key],
             [windowDuration, incrementBy]
           ) : Promise.resolve();
@@ -1537,8 +1576,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         const usedTokensAfterUpdate = await safeEval(
           ctx,
-          cachedFixedWindowLimitScript,
-          "limitHash",
+          SCRIPTS.singleRegion.cachedFixedWindow.limit,
           [key],
           [windowDuration, incrementBy]
         );
@@ -1568,8 +1606,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         const usedTokens = await safeEval(
           ctx,
-          cachedFixedWindowRemainingTokenScript,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.cachedFixedWindow.getRemaining,
           [key],
           [null]
         );
@@ -1588,8 +1625,7 @@ var RegionRatelimit = class extends Ratelimit {
         const pattern = [identifier, "*"].join(":");
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );