@zlink-systems/framework-locations-redis 0.25.0 → 0.27.0

package/dist/relocation-store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRedisRelocationStore = void 0;
+const framework_internal_1 = require("./framework-internal");
 const redis_connection_1 = require("./redis-connection");
 const opaque_redis_scripts_1 = require("./opaque-redis-scripts");
 const redis_values_1 = require("./redis-values");
@@ -21,12 +22,12 @@ class ZLinkRedisRelocationStore {
         requirePayload(payload);
         const retention = requireRetention(retentionMs);
         const result = (0, redis_values_1.asArray)(await this.connection.eval(opaque_redis_scripts_1.BLOB_PUT_SCRIPT, [this.blobKey(referenceValue)], [Buffer.from(payload), String(retention)], signal));
-        const kind = (0, redis_values_1.asString)(result[0]);
+        const outcome = (0, redis_values_1.asString)(result[0]);
         const storeNow = fromUnixMs((0, redis_values_1.toNumber)(result[1]));
-        if (kind === 'conflict')
-            return { kind, storeNow };
+        if (outcome === opaque_redis_scripts_1.REDIS_STORE_TOKEN.Conflict)
+            return { kind: 'conflict', storeNow };
         return {
-            kind: kind === 'alreadyStored' ? 'alreadyStored' : 'stored',
+            kind: outcome === opaque_redis_scripts_1.REDIS_STORE_TOKEN.AlreadyStored ? 'alreadyStored' : 'stored',
             storeNow,
             expiresAt: fromUnixMs((0, redis_values_1.toNumber)(result[2]))
         };
@@ -72,21 +73,23 @@ exports.ZLinkRedisRelocationStore = ZLinkRedisRelocationStore;
 function requireReference(reference) {
     const value = reference.value;
     const bytes = Buffer.byteLength(value, 'utf8');
-    if (bytes < 1 || bytes > 4_096) {
-        throw new RangeError('Relocation Store reference must contain 1..4,096 UTF-8 bytes.');
+    if (bytes < 1 || bytes > framework_internal_1.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES) {
+        throw new RangeError(`Relocation Store reference must contain 1..${framework_internal_1.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES.toLocaleString('en-US')} UTF-8 bytes.`);
     }
     return value;
 }
 function requirePayload(payload) {
     if (payload.byteLength > MAX_ENCODED_BLOB_BYTES) {
-        throw new RangeError('Relocation Store encoded blob exceeds 64 MiB + 23 bytes.');
+        throw new RangeError(`Relocation Store encoded blob exceeds ${Math.floor(MAX_ENCODED_BLOB_BYTES / (1024 * 1024))} MiB + ${MAX_ENCODED_BLOB_BYTES % (1024 * 1024)} bytes.`);
     }
 }
 function requireRetention(retentionMs) {
-    if (!Number.isSafeInteger(retentionMs) || retentionMs < 1) {
-        throw new RangeError('Relocation Store retention must be a positive safe integer.');
+    if (!Number.isFinite(retentionMs) ||
+        retentionMs <= 0 ||
+        !Number.isSafeInteger(Math.ceil(retentionMs))) {
+        throw new RangeError('Relocation Store retention must round to a positive safe integer.');
     }
-    return retentionMs;
+    return Math.ceil(retentionMs);
 }
 function asBuffer(value) {
     if (Buffer.isBuffer(value))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework-locations-redis",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -17,8 +17,8 @@
     }
   },
   "dependencies": {
-    "@zlink-systems/framework": "0.25.0",
-    "@zlink-systems/zlink": "1.7.0",
+    "@zlink-systems/framework": "0.27.0",
+    "@zlink-systems/zlink": "1.14.0",
     "redis": "^6.1.0"
   }
 }

package/src/framework-internal.ts

@@ -0,0 +1,20 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+const requireFramework = createRequire(__filename);
+const frameworkEntry = requireFramework.resolve('@zlink-systems/framework');
+const internal = requireFramework(
+  path.join(path.dirname(frameworkEntry), 'internal')
+) as typeof import('../../framework/src/internal');
+
+export const {
+  ZLINK_PROVIDER_MAX_KEY_BYTES,
+  ZLINK_PROVIDER_MAX_VALUE_BYTES,
+  ZLINK_PROVIDER_MAX_VERSION_BYTES,
+  ZLINK_PROVIDER_MAX_WRITE_KEYS,
+  ZLINK_PROVIDER_MAX_WRITE_BYTES,
+  ZLINK_PROVIDER_MAX_ENCODED_PAGE_BYTES,
+  ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES,
+  ZLINK_PROVIDER_MAX_PAGE_SIZE,
+  ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES
+} = internal;

package/src/opaque-redis-scripts.ts

@@ -1,7 +1,38 @@
+import { ZLINK_PROVIDER_MAX_ENCODED_PAGE_BYTES } from './framework-internal';
+const REDIS_MILLISECONDS_PER_SECOND = 1000;
+const REDIS_MICROSECONDS_PER_MILLISECOND = 1000;
+const REDIS_CLEANUP_RETRY_DELAY_MS = 1000;
+const REDIS_EXPIRED_SNAPSHOT_BATCH_SIZE = 128;
+const REDIS_ROW_COMPACTION_ENTRY_LIMIT = 128;
+const REDIS_SCAN_MINIMUM_WORK_BUDGET = 128;
+const REDIS_ENCODED_ITEM_OVERHEAD_BYTES = 128;
+const REDIS_SCAN_WORK_BUDGET_MULTIPLIER = 4;
+const REDIS_CLEANUP_BATCH_SIZE = 32;
+const REDIS_RECORD_RETENTION_MS = 60000;
+const REDIS_SCAN_SNAPSHOT_RETENTION_MS = 60000;
+const REDIS_MAX_SCAN_SNAPSHOTS = 4096;
+const REDIS_UTF8_PREFIX_UPPER_BOUND_BYTE = 0xff;
+
+export const REDIS_STORE_TOKEN = Object.freeze({
+  Conflict: 'conflict',
+  Backlog: 'backlog',
+  Applied: 'applied',
+  Expired: 'expired',
+  Capacity: 'capacity',
+  Page: 'page',
+  AlreadyStored: 'alreadyStored',
+  Stored: 'stored',
+  Missing: 'missing',
+  Value: 'value',
+  Version: 'version',
+  Put: 'put',
+  Delete: 'delete'
+} as const);
+
 const PROLOGUE = `
 if redis.replicate_commands then redis.replicate_commands() end
 local time = redis.call('TIME')
-local nowMs = tonumber(time[1]) * 1000 + math.floor(tonumber(time[2]) / 1000)
+local nowMs = tonumber(time[1]) * ${REDIS_MILLISECONDS_PER_SECOND} + math.floor(tonumber(time[2]) / ${REDIS_MICROSECONDS_PER_MILLISECOND})
 `;
 
 // Shared decode helper. Every opaque row is a Redis ZSET append-log; the
@@ -38,14 +69,15 @@ local function encodeMember(originalKey, bytes, version, expiresAtMs, tombstone)
 end
 `;
 
-export const OPAQUE_READ_SCRIPT =
+export const OPAQUE_READ_SCRIPT = Buffer.from(
   PROLOGUE +
-  DECODE_HELPERS +
-  `
+    DECODE_HELPERS +
+    `
 local record = liveRecordAt(KEYS[1], nowMs)
 if not record then return {0, nowMs} end
 return {1, nowMs, record[1], record[2], record[3], tostring(tonumber(record[4]))}
-`;
+`
+);
 
 // KEYS[1..6] = indexKey, mapKey, cleanupKey, sequenceKey, snapshotExpiryKey,
 // snapshotBoundaryKey (private auxiliary keys, not part of the public
@@ -53,22 +85,29 @@ return {1, nowMs, record[1], record[2], record[3], tostring(tonumber(record[4]))
 // conditions/mutations, in the order fixed by ARGV[1]/ARGV[2].
 // ARGV[1] = JSON conditions: ['missing', keyIndex, originalKey]
 //           | ['version', keyIndex, originalKey, expectedVersion]
+//           | ['value', keyIndex, originalKey, expectedBytesArgIndex]
 // ARGV[2] = JSON mutation metadata (no raw bytes, JSON must stay text-safe):
 //           ['put', keyIndex, originalKey, retentionMsOrFalse]
 //           | ['delete', keyIndex, originalKey]
-// ARGV[3..] = one raw-bytes argument per 'put' mutation, in mutation order.
-export const OPAQUE_WRITE_SCRIPT =
-  PROLOGUE +
-  DECODE_HELPERS +
-  `
-local indexKey = KEYS[1]
-local mapKey = KEYS[2]
-local cleanupKey = KEYS[3]
-local sequenceKey = KEYS[4]
-local snapshotExpiryKey = KEYS[5]
-local snapshotBoundaryKey = KEYS[6]
+// ARGV[3..] = raw expected bytes for 'value' conditions, then raw bytes for
+//             'put' mutations, each in request order.
+const PRUNE_HISTORY_HELPER = `
+local function pruneHistory(rowKey, minimumBoundary)
+    if minimumBoundary then
+        local anchor = redis.call('ZREVRANGEBYSCORE', rowKey, minimumBoundary, '-inf', 'WITHSCORES', 'LIMIT', 0, 1)
+        if #anchor == 2 then
+            redis.call('ZREMRANGEBYSCORE', rowKey, '-inf', '(' .. anchor[2])
+        end
+    else
+        redis.call('ZREMRANGEBYRANK', rowKey, 0, -2)
+    end
+end
+`;
 
-local expiredSnapshots = redis.call('ZRANGEBYSCORE', snapshotExpiryKey, '-inf', nowMs, 'LIMIT', 0, 128)
+const CLEANUP_AND_BOUNDARY =
+  PRUNE_HISTORY_HELPER +
+  `
+local expiredSnapshots = redis.call('ZRANGEBYSCORE', snapshotExpiryKey, '-inf', nowMs, 'LIMIT', 0, ${REDIS_EXPIRED_SNAPSHOT_BATCH_SIZE})
 for _, snapshotId in ipairs(expiredSnapshots) do
     redis.call('ZREM', snapshotExpiryKey, snapshotId)
     redis.call('ZREM', snapshotBoundaryKey, snapshotId)
@@ -77,7 +116,7 @@ local minimumBoundary = nil
 local boundaryEntry = redis.call('ZRANGE', snapshotBoundaryKey, 0, 0, 'WITHSCORES')
 if #boundaryEntry == 2 then minimumBoundary = tonumber(boundaryEntry[2]) end
 
-local due = redis.call('ZRANGEBYSCORE', cleanupKey, '-inf', nowMs, 'LIMIT', 0, 32)
+local due = redis.call('ZRANGEBYSCORE', cleanupKey, '-inf', nowMs, 'LIMIT', 0, ${REDIS_CLEANUP_BATCH_SIZE})
 for _, original in ipairs(due) do
     local rowKey = redis.call('HGET', mapKey, original)
     local members = {}
@@ -89,23 +128,20 @@ for _, original in ipairs(due) do
         redis.call('HDEL', mapKey, original)
         redis.call('ZREM', cleanupKey, original)
     elseif minimumBoundary then
-        local anchor = redis.call('ZREVRANGEBYSCORE', rowKey, minimumBoundary, '-inf', 'WITHSCORES', 'LIMIT', 0, 1)
-        if #anchor == 2 then
-            redis.call('ZREMRANGEBYSCORE', rowKey, '-inf', '(' .. anchor[2])
-        end
-        redis.call('ZADD', cleanupKey, nowMs + 1000, original)
+        pruneHistory(rowKey, minimumBoundary)
+        redis.call('ZADD', cleanupKey, nowMs + ${REDIS_CLEANUP_RETRY_DELAY_MS}, original)
     else
         local record = decodeMember(members[1])
         local expiresAtMs = tonumber(record[4])
-        if record[5] == true or (expiresAtMs > 0 and expiresAtMs + 60000 <= nowMs) then
+        if record[5] == true or (expiresAtMs > 0 and expiresAtMs + ${REDIS_RECORD_RETENTION_MS} <= nowMs) then
             redis.call('DEL', rowKey)
             redis.call('ZREM', indexKey, original)
             redis.call('HDEL', mapKey, original)
             redis.call('ZREM', cleanupKey, original)
         else
-            redis.call('ZREMRANGEBYRANK', rowKey, 0, -2)
+            pruneHistory(rowKey, minimumBoundary)
             if expiresAtMs > 0 then
-                redis.call('ZADD', cleanupKey, math.max(nowMs + 1000, expiresAtMs + 60000), original)
+                redis.call('ZADD', cleanupKey, math.max(nowMs + ${REDIS_CLEANUP_RETRY_DELAY_MS}, expiresAtMs + ${REDIS_RECORD_RETENTION_MS}), original)
             else
                 redis.call('ZREM', cleanupKey, original)
             end
@@ -113,36 +149,57 @@ for _, original in ipairs(due) do
     end
 end
 
+`;
+
+export const OPAQUE_WRITE_SCRIPT = Buffer.from(
+  PROLOGUE +
+    DECODE_HELPERS +
+    `
+local indexKey = KEYS[1]
+local mapKey = KEYS[2]
+local cleanupKey = KEYS[3]
+local sequenceKey = KEYS[4]
+local snapshotExpiryKey = KEYS[5]
+local snapshotBoundaryKey = KEYS[6]
+
+` +
+    CLEANUP_AND_BOUNDARY +
+    `
 local conditions = cjson.decode(ARGV[1])
 local mutations = cjson.decode(ARGV[2])
 
 for _, condition in ipairs(conditions) do
     local record = liveRecordAt(KEYS[condition[2] + 6], nowMs)
     local currentVersion = record and record[3] or nil
-    if condition[1] == 'missing' then
-        if currentVersion ~= nil then return {'conflict', nowMs} end
+    if condition[1] == '${REDIS_STORE_TOKEN.Missing}' then
+        if currentVersion ~= nil then return {'${REDIS_STORE_TOKEN.Conflict}', nowMs} end
+    elseif condition[1] == '${REDIS_STORE_TOKEN.Value}' then
+        if not record or record[2] ~= ARGV[condition[4]] then
+            return {'${REDIS_STORE_TOKEN.Conflict}', nowMs}
+        end
     elseif currentVersion ~= condition[4] then
-        return {'conflict', nowMs}
+        return {'${REDIS_STORE_TOKEN.Conflict}', nowMs}
     end
 end
 
 for _, mutation in ipairs(mutations) do
     local rowKey = KEYS[mutation[2] + 6]
-    if not minimumBoundary then
-        redis.call('ZREMRANGEBYRANK', rowKey, 0, -2)
-    end
-    if redis.call('ZCARD', rowKey) >= 128 then
-        return {'backlog', nowMs}
+    pruneHistory(rowKey, minimumBoundary)
+    if redis.call('ZCARD', rowKey) >= ${REDIS_ROW_COMPACTION_ENTRY_LIMIT} then
+        return {'${REDIS_STORE_TOKEN.Backlog}', nowMs}
     end
 end
 
 local sequence = tostring(redis.call('INCR', sequenceKey))
 local byteArg = 3
-local result = {'applied', nowMs}
+for _, condition in ipairs(conditions) do
+    if condition[1] == '${REDIS_STORE_TOKEN.Value}' then byteArg = byteArg + 1 end
+end
+local result = {'${REDIS_STORE_TOKEN.Applied}', nowMs}
 for _, mutation in ipairs(mutations) do
     local rowKey = KEYS[mutation[2] + 6]
     local originalKey = mutation[3]
-    if mutation[1] == 'put' then
+    if mutation[1] == '${REDIS_STORE_TOKEN.Put}' then
         local bytes = ARGV[byteArg]
         byteArg = byteArg + 1
         local retention = mutation[4]
@@ -158,14 +215,15 @@ for _, mutation in ipairs(mutations) do
         redis.call('ZADD', indexKey, 0, originalKey)
         redis.call('HSET', mapKey, originalKey, rowKey)
     end
-    local dueAt = nowMs + 1000
+    local dueAt = nowMs + ${REDIS_CLEANUP_RETRY_DELAY_MS}
     local scheduled = redis.call('ZSCORE', cleanupKey, originalKey)
     if not scheduled or tonumber(scheduled) > dueAt then
         redis.call('ZADD', cleanupKey, dueAt, originalKey)
     end
 end
 return result
-`;
+`
+);
 
 // Shared body for point-in-time paged scanning. KEYS[1]=indexKey,
 // KEYS[2]=mapKey, KEYS[3]=snapshotKey, KEYS[4]=cleanupKey,
@@ -173,93 +231,54 @@ return result
 const SCAN_CLEANUP_AND_BOUNDARY =
   DECODE_HELPERS +
   `
-local expiredSnapshots = redis.call('ZRANGEBYSCORE', KEYS[6], '-inf', nowMs, 'LIMIT', 0, 128)
-for _, expiredId in ipairs(expiredSnapshots) do
-    redis.call('ZREM', KEYS[6], expiredId)
-    redis.call('ZREM', KEYS[7], expiredId)
-end
-local minimumBoundary = nil
-local boundaryEntry = redis.call('ZRANGE', KEYS[7], 0, 0, 'WITHSCORES')
-if #boundaryEntry == 2 then minimumBoundary = tonumber(boundaryEntry[2]) end
-
-local due = redis.call('ZRANGEBYSCORE', KEYS[4], '-inf', nowMs, 'LIMIT', 0, 32)
-for _, original in ipairs(due) do
-    local rowKey = redis.call('HGET', KEYS[2], original)
-    local members = {}
-    if rowKey then
-        members = redis.call('ZREVRANGE', rowKey, 0, 0, 'WITHSCORES')
-    end
-    if #members == 0 then
-        redis.call('ZREM', KEYS[1], original)
-        redis.call('HDEL', KEYS[2], original)
-        redis.call('ZREM', KEYS[4], original)
-    elseif minimumBoundary then
-        local anchor = redis.call('ZREVRANGEBYSCORE', rowKey, minimumBoundary, '-inf', 'WITHSCORES', 'LIMIT', 0, 1)
-        if #anchor == 2 then
-            redis.call('ZREMRANGEBYSCORE', rowKey, '-inf', '(' .. anchor[2])
-        end
-        redis.call('ZADD', KEYS[4], nowMs + 1000, original)
-    else
-        local record = decodeMember(members[1])
-        local expiresAtMs = tonumber(record[4])
-        if record[5] == true or (expiresAtMs > 0 and expiresAtMs + 60000 <= nowMs) then
-            redis.call('DEL', rowKey)
-            redis.call('ZREM', KEYS[1], original)
-            redis.call('HDEL', KEYS[2], original)
-            redis.call('ZREM', KEYS[4], original)
-        else
-            redis.call('ZREMRANGEBYRANK', rowKey, 0, -2)
-            if expiresAtMs > 0 then
-                redis.call('ZADD', KEYS[4], math.max(nowMs + 1000, expiresAtMs + 60000), original)
-            else
-                redis.call('ZREM', KEYS[4], original)
-            end
-        end
-    end
-end
-`;
+local indexKey = KEYS[1]
+local mapKey = KEYS[2]
+local cleanupKey = KEYS[4]
+local snapshotExpiryKey = KEYS[6]
+local snapshotBoundaryKey = KEYS[7]
+` +
+  CLEANUP_AND_BOUNDARY;
 
 const SCAN_PAGE_READ = `
 local metadata = redis.call('HMGET', KEYS[3], 'now', 'boundary', 'prefix')
 if not metadata[1] or metadata[3] ~= prefix then
     redis.call('ZREM', KEYS[6], snapshotId)
     redis.call('ZREM', KEYS[7], snapshotId)
-    return {'expired'}
+    return {'${REDIS_STORE_TOKEN.Expired}'}
 end
 local snapshotNow = tonumber(metadata[1])
 local boundary = tonumber(metadata[2])
-local lower = '-'
+local lower = '[' .. prefix
+local upper = '[' .. prefix .. string.char(${REDIS_UTF8_PREFIX_UPPER_BOUND_BYTE})
 if string.len(lastKey) > 0 then lower = '(' .. lastKey end
-local workLimit = math.max(limit * 4, 128)
-local originals = redis.call('ZRANGEBYLEX', KEYS[1], lower, '+', 'LIMIT', 0, workLimit + 1)
+local workLimit = math.max(limit * ${REDIS_SCAN_WORK_BUDGET_MULTIPLIER}, ${REDIS_SCAN_MINIMUM_WORK_BUDGET})
+local originals = redis.call('ZRANGEBYLEX', KEYS[1], lower, upper, 'LIMIT', 0, workLimit + 1)
 local emitted = 0
 local encodedBytes = 0
 local examined = 0
-local result = {'page', tostring(snapshotNow), ''}
+local result = {'${REDIS_STORE_TOKEN.Page}', tostring(snapshotNow), ''}
 while examined < #originals and examined < workLimit and emitted < limit do
     local original = originals[examined + 1]
     examined = examined + 1
-    if string.sub(original, 1, string.len(prefix)) == prefix then
-        local rowKey = redis.call('HGET', KEYS[2], original)
-        if rowKey then
-            local members = redis.call('ZREVRANGEBYSCORE', rowKey, boundary, '-inf', 'LIMIT', 0, 1)
-            if #members > 0 then
-                local record = decodeMember(members[1])
-                local expiresAtMs = tonumber(record[4])
-                if record[1] == original and record[5] ~= true
-                    and (expiresAtMs == 0 or expiresAtMs > snapshotNow) then
-                    local itemBytes = string.len(original) + string.len(record[2]) + string.len(record[3]) + 128
-                    if emitted > 0 and encodedBytes + itemBytes > 4194304 then
-                        examined = examined - 1
-                        break
-                    end
-                    table.insert(result, original)
-                    table.insert(result, record[2])
-                    table.insert(result, record[3])
-                    table.insert(result, tostring(expiresAtMs))
-                    encodedBytes = encodedBytes + itemBytes
-                    emitted = emitted + 1
+    local rowKey = redis.call('HGET', KEYS[2], original)
+    if rowKey then
+        local members = redis.call('ZREVRANGEBYSCORE', rowKey, boundary, '-inf', 'LIMIT', 0, 1)
+        if #members > 0 then
+            local record = decodeMember(members[1])
+            local expiresAtMs = tonumber(record[4])
+            if record[1] == original and record[5] ~= true
+                and (expiresAtMs == 0 or expiresAtMs > snapshotNow) then
+                local itemBytes = string.len(original) + string.len(record[2]) + string.len(record[3]) + ${REDIS_ENCODED_ITEM_OVERHEAD_BYTES}
+                if emitted > 0 and encodedBytes + itemBytes > ${ZLINK_PROVIDER_MAX_ENCODED_PAGE_BYTES} then
+                    examined = examined - 1
+                    break
                 end
+                table.insert(result, original)
+                table.insert(result, record[2])
+                table.insert(result, record[3])
+                table.insert(result, tostring(expiresAtMs))
+                encodedBytes = encodedBytes + itemBytes
+                emitted = emitted + 1
             end
         end
     end
@@ -287,14 +306,14 @@ local limit = tonumber(ARGV[2])
 local snapshotId = ARGV[3]
 local lastKey = ''
 
-if redis.call('ZCARD', KEYS[6]) >= 4096 then
-    return {'capacity'}
+if redis.call('ZCARD', KEYS[6]) >= ${REDIS_MAX_SCAN_SNAPSHOTS} then
+    return {'${REDIS_STORE_TOKEN.Capacity}'}
 end
 redis.call('DEL', KEYS[3])
 local boundary = tonumber(redis.call('GET', KEYS[5]) or '0')
 redis.call('HSET', KEYS[3], 'now', tostring(nowMs), 'boundary', tostring(boundary), 'prefix', prefix)
-redis.call('PEXPIRE', KEYS[3], 60000)
-redis.call('ZADD', KEYS[6], nowMs + 60000, snapshotId)
+redis.call('PEXPIRE', KEYS[3], ${REDIS_SCAN_SNAPSHOT_RETENTION_MS})
+redis.call('ZADD', KEYS[6], nowMs + ${REDIS_SCAN_SNAPSHOT_RETENTION_MS}, snapshotId)
 redis.call('ZADD', KEYS[7], boundary, snapshotId)
 ` +
   SCAN_PAGE_READ;
@@ -312,7 +331,7 @@ local snapshotId = ARGV[4]
 if redis.call('EXISTS', KEYS[3]) == 0 then
     redis.call('ZREM', KEYS[6], snapshotId)
     redis.call('ZREM', KEYS[7], snapshotId)
-    return {'expired'}
+    return {'${REDIS_STORE_TOKEN.Expired}'}
 end
 ` +
   SCAN_PAGE_READ;
@@ -328,15 +347,15 @@ export const BLOB_PUT_SCRIPT =
 local existing = redis.call('GET', KEYS[1])
 if existing then
     if existing ~= ARGV[1] then
-        return {'conflict', nowMs}
+        return {'${REDIS_STORE_TOKEN.Conflict}', nowMs}
     end
     local ttl = redis.call('PTTL', KEYS[1])
     local expiresAtMs = nowMs + math.max(ttl, 0)
-    return {'alreadyStored', nowMs, tostring(expiresAtMs)}
+    return {'${REDIS_STORE_TOKEN.AlreadyStored}', nowMs, tostring(expiresAtMs)}
 end
 local retentionMs = tonumber(ARGV[2])
 redis.call('SET', KEYS[1], ARGV[1], 'PX', retentionMs)
-return {'stored', nowMs, tostring(nowMs + retentionMs)}
+return {'${REDIS_STORE_TOKEN.Stored}', nowMs, tostring(nowMs + retentionMs)}
 `;
 
 export const BLOB_READ_SCRIPT =