memx 0.0.4 → 0.0.7

package/dist/index.mjs

@@ -274,25 +274,13 @@ __export(connection_exports, {
 
 // src/internals.ts
 import assert2 from "assert";
-import {
-  isUint8Array,
-  isUint8ClampedArray,
-  isUint16Array,
-  isUint32Array,
-  isInt8Array,
-  isInt16Array,
-  isInt32Array,
-  isBigUint64Array,
-  isBigInt64Array,
-  isFloat32Array,
-  isFloat64Array
-} from "util/types";
+import { types } from "util";
 var socketFinalizationRegistry = new FinalizationRegistry((socket) => {
   if (!socket.destroyed)
     socket.destroy();
 });
 function typedArrayFlags(value) {
-  const flags = isUint8Array(value) ? 3402235920 /* UINT8ARRAY */ : isUint8ClampedArray(value) ? 3402235921 /* UINT8CLAMPEDARRAY */ : isUint16Array(value) ? 3402235922 /* UINT16ARRAY */ : isUint32Array(value) ? 3402235923 /* UINT32ARRAY */ : isInt8Array(value) ? 3402235924 /* INT8ARRAY */ : isInt16Array(value) ? 3402235925 /* INT16ARRAY */ : isInt32Array(value) ? 3402235926 /* INT32ARRAY */ : isBigUint64Array(value) ? 3402235927 /* BIGUINT64ARRAY */ : isBigInt64Array(value) ? 3402235928 /* BIGINT64ARRAY */ : isFloat32Array(value) ? 3402235929 /* FLOAT32ARRAY */ : isFloat64Array(value) ? 3402235930 /* FLOAT64ARRAY */ : assert2.fail("Unsupported kind of TypedArray");
+  const flags = types.isUint8Array(value) ? 3402235920 /* UINT8ARRAY */ : types.isUint8ClampedArray(value) ? 3402235921 /* UINT8CLAMPEDARRAY */ : types.isUint16Array(value) ? 3402235922 /* UINT16ARRAY */ : types.isUint32Array(value) ? 3402235923 /* UINT32ARRAY */ : types.isInt8Array(value) ? 3402235924 /* INT8ARRAY */ : types.isInt16Array(value) ? 3402235925 /* INT16ARRAY */ : types.isInt32Array(value) ? 3402235926 /* INT32ARRAY */ : types.isBigUint64Array(value) ? 3402235927 /* BIGUINT64ARRAY */ : types.isBigInt64Array(value) ? 3402235928 /* BIGINT64ARRAY */ : types.isFloat32Array(value) ? 3402235929 /* FLOAT32ARRAY */ : types.isFloat64Array(value) ? 3402235930 /* FLOAT64ARRAY */ : assert2.fail("Unsupported kind of TypedArray");
   return flags;
 }
 function logPromiseError(promise, message) {
@@ -441,144 +429,6 @@ var Connection = class {
   }
 };
 
-// src/fake.ts
-function toExp(ttl = 0) {
-  if (ttl === 0)
-    return Number.MAX_SAFE_INTEGER;
-  return Date.now() + ttl * 1e3;
-}
-var FakeAdapter = class {
-  #cache = /* @__PURE__ */ new Map();
-  #cas = 1n;
-  #get(key) {
-    if (key.length > 250)
-      throw new TypeError(`Key too long (len=${key.length})`);
-    const entry = this.#cache.get(key);
-    if (!entry)
-      return;
-    if (Date.now() > entry.exp) {
-      this.#cache.delete(key);
-      return;
-    }
-    return entry;
-  }
-  #set(key, value, flags, ttl) {
-    this.#cache.set(key, {
-      value,
-      flags: flags || 0,
-      cas: ++this.#cas,
-      exp: toExp(ttl)
-    });
-    return this.#cas;
-  }
-  async get(key, options = {}) {
-    const entry = this.#get(key);
-    if (!entry)
-      return;
-    if (options.ttl !== void 0) {
-      const exp = toExp(options.ttl);
-      entry.exp = exp;
-    }
-    return {
-      value: entry.value,
-      flags: entry.flags,
-      cas: entry.cas,
-      recycle: () => void 0
-    };
-  }
-  async touch(key, ttl) {
-    const entry = this.#get(key);
-    if (entry)
-      entry.exp = toExp(ttl);
-    return !!entry;
-  }
-  async set(key, value, options = {}) {
-    const entry = this.#get(key);
-    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
-      return;
-    }
-    return this.#set(key, value, options.flags, options.ttl);
-  }
-  async add(key, value, options = {}) {
-    if (this.#get(key))
-      return;
-    return this.#set(key, value, options.flags, options.ttl);
-  }
-  async replace(key, value, options = {}) {
-    if (!this.#get(key))
-      return;
-    return this.#set(key, value, options.flags, options.ttl);
-  }
-  async append(key, value, options = {}) {
-    const entry = this.#get(key);
-    if (!entry)
-      return false;
-    if (options.cas !== void 0 && options.cas !== entry.cas)
-      return false;
-    entry.value = Buffer.concat([entry.value, value]);
-    return true;
-  }
-  async prepend(key, value, options = {}) {
-    const entry = this.#get(key);
-    if (!entry)
-      return false;
-    if (options.cas !== void 0 && options.cas !== entry.cas)
-      return false;
-    entry.value = Buffer.concat([value, entry.value]);
-    return true;
-  }
-  async #counter(key, delta, options) {
-    const entry = this.#get(key);
-    if (!entry) {
-      if (options.initial !== void 0) {
-        const value = Buffer.from(options.initial.toString());
-        this.#set(key, value, void 0, options.ttl);
-        return { value: BigInt(options.initial), cas: this.#cas };
-      } else {
-        return;
-      }
-    }
-    if (options.cas !== void 0 && options.cas !== entry.cas)
-      return;
-    try {
-      const value = BigInt(entry.value.toString("utf-8")) + BigInt(delta);
-      this.#set(key, Buffer.from(value.toString()), void 0, options.ttl);
-      return { value, cas: this.#cas };
-    } catch (error) {
-      throw new TypeError(`${error.message} (status=NON_NUMERIC_VALUE, key=${key})`);
-    }
-  }
-  increment(key, delta = 1n, options = {}) {
-    return this.#counter(key, delta, options);
-  }
-  decrement(key, delta = 1n, options = {}) {
-    return this.#counter(key, -delta, options);
-  }
-  async delete(key, options = {}) {
-    const entry = this.#get(key);
-    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
-      return false;
-    }
-    return this.#cache.delete(key);
-  }
-  async flush(ttl) {
-    if (!ttl)
-      return this.#cache.clear();
-    const wait = toExp(ttl) - Date.now();
-    setTimeout(() => this.#cache.clear(), wait);
-  }
-  async noop() {
-  }
-  async quit() {
-  }
-  async version() {
-    return { fake: "0.0.0-fake" };
-  }
-  async stats() {
-    return { fake: { version: "0.0.0-fake" } };
-  }
-};
-
 // src/server.ts
 var statsBigInt = [
   "auth_cmds",
@@ -726,10 +576,9 @@ var ServerAdapter = class {
       throw new Error(`Key too long (len=${keyLength})`);
     return keyLength;
   }
-  async get(key, options = {}) {
-    const { ttl } = options;
+  async #get(key, ttl) {
     let keyOffset = 0;
-    if (ttl)
+    if (ttl !== void 0)
       keyOffset = this.#buffer.writeUInt32BE(ttl);
     const keyLength = this.#writeKey(key, keyOffset);
     const [response] = await this.#connection.send({
@@ -755,8 +604,14 @@ var ServerAdapter = class {
         fail(response, key);
     }
   }
+  async get(key) {
+    return this.#get(key);
+  }
+  async gat(key, ttl) {
+    return this.#get(key, ttl || 2592e3);
+  }
   async touch(key, ttl) {
-    const timeToLive = ttl === void 0 ? this.#ttl : ttl;
+    const timeToLive = ttl ?? this.#ttl;
     const keyOffset = this.#buffer.writeUInt32BE(timeToLive);
     const keyLength = this.#writeKey(key, keyOffset);
     const [response] = await this.#connection.send({
@@ -1004,6 +859,7 @@ var ServerAdapter = class {
 };
 
 // src/cluster.ts
+import assert4 from "assert";
 function parseHosts(hosts) {
   const result = [];
   if (!hosts)
@@ -1017,6 +873,7 @@ function parseHosts(hosts) {
 }
 var ClusterAdapter = class {
   servers;
+  ttl;
   constructor(serversOrOptions) {
     if (Array.isArray(serversOrOptions)) {
       this.servers = [...serversOrOptions];
@@ -1044,6 +901,10 @@ var ClusterAdapter = class {
       throw new Error("No hosts configured");
     if (this.servers.length === 1)
       this.server = () => this.servers[0];
+    this.ttl = this.servers[0].ttl;
+    this.servers.slice(1).forEach((server) => {
+      assert4.equal(server.ttl, this.ttl, `TTL Mismatch (${server.ttl} != ${this.ttl})`);
+    });
     Object.freeze(this.servers);
   }
   server(key) {
@@ -1053,8 +914,11 @@ var ClusterAdapter = class {
       hash = hash * 31 + key.charCodeAt(i);
     return this.servers[hash % this.servers.length];
   }
-  get(key, options) {
-    return this.server(key).get(key, options);
+  get(key) {
+    return this.server(key).get(key);
+  }
+  gat(key, ttl) {
+    return this.server(key).gat(key, ttl);
   }
   touch(key, ttl) {
     return this.server(key).touch(key, ttl);
@@ -1103,8 +967,8 @@ var ClusterAdapter = class {
 };
 
 // src/client.ts
-import assert4 from "assert";
-import { isTypedArray } from "util/types";
+import assert5 from "assert";
+import { types as types2 } from "util";
 function replacer(key, value) {
   if (typeof this[key] === "bigint")
     return ["\0__$BIGINT$__\0", this[key].toString()];
@@ -1146,9 +1010,9 @@ function toBuffer(value, options) {
     case "object":
       break;
     default:
-      assert4.fail(`Unable to store value of type "${typeof value}"`);
+      assert5.fail(`Unable to store value of type "${typeof value}"`);
   }
-  if (isTypedArray(value)) {
+  if (types2.isTypedArray(value)) {
     const flags = typedArrayFlags(value);
     const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
     return [buffer, __spreadProps(__spreadValues({}, options), { flags })];
@@ -1158,12 +1022,58 @@ function toBuffer(value, options) {
   const json = JSON.stringify(value, replacer);
   return [Buffer.from(json, "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
 }
+function fromBuffer(result) {
+  try {
+    const { flags, value, cas } = result;
+    switch (flags) {
+      case 3402235904 /* BIGINT */:
+        return { value: BigInt(value.toString("utf-8")), cas };
+      case 3402235905 /* BOOLEAN */:
+        return { value: !!value[0], cas };
+      case 3402235906 /* NUMBER */:
+        return { value: Number(value.toString("utf-8")), cas };
+      case 3402235907 /* STRING */:
+        return { value: value.toString("utf-8"), cas };
+      case 3402235918 /* NULL */:
+        return { value: null, cas };
+      case 3402235919 /* JSON */:
+        return { value: JSON.parse(value.toString("utf-8"), reviver), cas };
+      case 3402235920 /* UINT8ARRAY */:
+        return { value: makeTypedArray(Uint8Array, value), cas };
+      case 3402235921 /* UINT8CLAMPEDARRAY */:
+        return { value: makeTypedArray(Uint8ClampedArray, value), cas };
+      case 3402235922 /* UINT16ARRAY */:
+        return { value: makeTypedArray(Uint16Array, value), cas };
+      case 3402235923 /* UINT32ARRAY */:
+        return { value: makeTypedArray(Uint32Array, value), cas };
+      case 3402235924 /* INT8ARRAY */:
+        return { value: makeTypedArray(Int8Array, value), cas };
+      case 3402235925 /* INT16ARRAY */:
+        return { value: makeTypedArray(Int16Array, value), cas };
+      case 3402235926 /* INT32ARRAY */:
+        return { value: makeTypedArray(Int32Array, value), cas };
+      case 3402235927 /* BIGUINT64ARRAY */:
+        return { value: makeTypedArray(BigUint64Array, value), cas };
+      case 3402235928 /* BIGINT64ARRAY */:
+        return { value: makeTypedArray(BigInt64Array, value), cas };
+      case 3402235929 /* FLOAT32ARRAY */:
+        return { value: makeTypedArray(Float32Array, value), cas };
+      case 3402235930 /* FLOAT64ARRAY */:
+        return { value: makeTypedArray(Float64Array, value), cas };
+      case 0 /* BUFFER */:
+      default:
+        return { value: Buffer.from(value), cas };
+    }
+  } finally {
+    result.recycle();
+  }
+}
 function makeTypedArray(constructor, source) {
   const clone = Buffer.from(source);
   const { buffer, byteOffset, byteLength } = clone;
   return new constructor(buffer, byteOffset, byteLength / constructor.BYTES_PER_ELEMENT);
 }
-var Client = class {
+var MemxClient = class {
   #adapter;
   #prefix;
   constructor(adapterOrOptions) {
@@ -1175,7 +1085,7 @@ var Client = class {
       this.#adapter = new ClusterAdapter(adapterOrOptions);
     }
     this.#prefix = "";
-    assert4(this.#adapter, "Invalid client constructor arguments");
+    assert5(this.#adapter, "Invalid client constructor arguments");
   }
   get adapter() {
     return this.#adapter;
@@ -1184,59 +1094,26 @@ var Client = class {
     return this.#prefix;
   }
   withPrefix(prefix) {
-    assert4(prefix, "Invalid prefix");
-    const client = new Client(this.#adapter);
+    assert5(prefix, "Invalid prefix");
+    const client = new MemxClient(this.#adapter);
     client.#prefix = prefix;
     return client;
   }
-  async get(key, options) {
-    const result = await this.#adapter.get(this.#prefix + key, options);
-    if (!result)
-      return;
-    try {
-      const { flags, value, cas } = result;
-      switch (flags) {
-        case 3402235904 /* BIGINT */:
-          return { value: BigInt(value.toString("utf-8")), cas };
-        case 3402235905 /* BOOLEAN */:
-          return { value: !!value[0], cas };
-        case 3402235906 /* NUMBER */:
-          return { value: Number(value.toString("utf-8")), cas };
-        case 3402235907 /* STRING */:
-          return { value: value.toString("utf-8"), cas };
-        case 3402235918 /* NULL */:
-          return { value: null, cas };
-        case 3402235919 /* JSON */:
-          return { value: JSON.parse(value.toString("utf-8"), reviver), cas };
-        case 3402235920 /* UINT8ARRAY */:
-          return { value: makeTypedArray(Uint8Array, value), cas };
-        case 3402235921 /* UINT8CLAMPEDARRAY */:
-          return { value: makeTypedArray(Uint8ClampedArray, value), cas };
-        case 3402235922 /* UINT16ARRAY */:
-          return { value: makeTypedArray(Uint16Array, value), cas };
-        case 3402235923 /* UINT32ARRAY */:
-          return { value: makeTypedArray(Uint32Array, value), cas };
-        case 3402235924 /* INT8ARRAY */:
-          return { value: makeTypedArray(Int8Array, value), cas };
-        case 3402235925 /* INT16ARRAY */:
-          return { value: makeTypedArray(Int16Array, value), cas };
-        case 3402235926 /* INT32ARRAY */:
-          return { value: makeTypedArray(Int32Array, value), cas };
-        case 3402235927 /* BIGUINT64ARRAY */:
-          return { value: makeTypedArray(BigUint64Array, value), cas };
-        case 3402235928 /* BIGINT64ARRAY */:
-          return { value: makeTypedArray(BigInt64Array, value), cas };
-        case 3402235929 /* FLOAT32ARRAY */:
-          return { value: makeTypedArray(Float32Array, value), cas };
-        case 3402235930 /* FLOAT64ARRAY */:
-          return { value: makeTypedArray(Float64Array, value), cas };
-        case 0 /* BUFFER */:
-        default:
-          return { value: Buffer.from(value), cas };
-      }
-    } finally {
-      result.recycle();
-    }
+  async get(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result).value;
+  }
+  async gat(key, ttl) {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl);
+    return result && fromBuffer(result).value;
+  }
+  async getc(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result);
+  }
+  async gatc(key, ttl) {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl);
+    return result && fromBuffer(result);
   }
   async set(key, value, options) {
     return this.#adapter.set(this.#prefix + key, ...toBuffer(value, options));
@@ -1292,23 +1169,177 @@ var Client = class {
   }
 };
 
+// src/fake.ts
+function toExp(ttl = 0) {
+  if (ttl === 0)
+    return Number.MAX_SAFE_INTEGER;
+  return Date.now() + ttl * 1e3;
+}
+var FakeAdapter = class {
+  #cache = /* @__PURE__ */ new Map();
+  #cas = 1n;
+  ttl = 0;
+  #get(key) {
+    if (key.length > 250)
+      throw new TypeError(`Key too long (len=${key.length})`);
+    const entry = this.#cache.get(key);
+    if (!entry)
+      return;
+    if (Date.now() > entry.exp) {
+      this.#cache.delete(key);
+      return;
+    }
+    return entry;
+  }
+  #set(key, value, flags, ttl) {
+    this.#cache.set(key, {
+      value,
+      flags: flags || 0,
+      cas: ++this.#cas,
+      exp: toExp(ttl)
+    });
+    return this.#cas;
+  }
+  async get(key) {
+    const entry = this.#get(key);
+    if (!entry)
+      return;
+    return {
+      value: entry.value,
+      flags: entry.flags,
+      cas: entry.cas,
+      recycle: () => void 0
+    };
+  }
+  async gat(key, ttl) {
+    const entry = this.#get(key);
+    if (!entry)
+      return;
+    entry.exp = toExp(ttl);
+    return {
+      value: entry.value,
+      flags: entry.flags,
+      cas: entry.cas,
+      recycle: () => void 0
+    };
+  }
+  async touch(key, ttl) {
+    const entry = this.#get(key);
+    if (entry)
+      entry.exp = toExp(ttl);
+    return !!entry;
+  }
+  async set(key, value, options = {}) {
+    const entry = this.#get(key);
+    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
+      return;
+    }
+    return this.#set(key, value, options.flags, options.ttl);
+  }
+  async add(key, value, options = {}) {
+    if (this.#get(key))
+      return;
+    return this.#set(key, value, options.flags, options.ttl);
+  }
+  async replace(key, value, options = {}) {
+    if (!this.#get(key))
+      return;
+    return this.#set(key, value, options.flags, options.ttl);
+  }
+  async append(key, value, options = {}) {
+    const entry = this.#get(key);
+    if (!entry)
+      return false;
+    if (options.cas !== void 0 && options.cas !== entry.cas)
+      return false;
+    entry.value = Buffer.concat([entry.value, value]);
+    return true;
+  }
+  async prepend(key, value, options = {}) {
+    const entry = this.#get(key);
+    if (!entry)
+      return false;
+    if (options.cas !== void 0 && options.cas !== entry.cas)
+      return false;
+    entry.value = Buffer.concat([value, entry.value]);
+    return true;
+  }
+  async #counter(key, delta, options) {
+    const entry = this.#get(key);
+    if (!entry) {
+      if (options.initial !== void 0) {
+        const value = Buffer.from(options.initial.toString());
+        this.#set(key, value, void 0, options.ttl);
+        return { value: BigInt(options.initial), cas: this.#cas };
+      } else {
+        return;
+      }
+    }
+    if (options.cas !== void 0 && options.cas !== entry.cas)
+      return;
+    try {
+      const value = BigInt(entry.value.toString("utf-8")) + BigInt(delta);
+      this.#set(key, Buffer.from(value.toString()), void 0, options.ttl);
+      return { value, cas: this.#cas };
+    } catch (error) {
+      throw new TypeError(`${error.message} (status=NON_NUMERIC_VALUE, key=${key})`);
+    }
+  }
+  increment(key, delta = 1n, options = {}) {
+    return this.#counter(key, delta, options);
+  }
+  decrement(key, delta = 1n, options = {}) {
+    return this.#counter(key, -delta, options);
+  }
+  async delete(key, options = {}) {
+    const entry = this.#get(key);
+    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
+      return false;
+    }
+    return this.#cache.delete(key);
+  }
+  async flush(ttl) {
+    if (!ttl)
+      return this.#cache.clear();
+    const wait = toExp(ttl) - Date.now();
+    setTimeout(() => this.#cache.clear(), wait);
+  }
+  async noop() {
+  }
+  async quit() {
+  }
+  async version() {
+    return { fake: "0.0.0-fake" };
+  }
+  async stats() {
+    return { fake: { version: "0.0.0-fake" } };
+  }
+};
+var MemxFakeClient = class extends MemxClient {
+  constructor() {
+    super(new FakeAdapter());
+  }
+};
+
 // src/utils.ts
-import assert5 from "assert";
+import assert6 from "assert";
 var Factory = class {
   #factory;
   #client;
   #ttl;
   constructor(client, factory, ttl) {
-    assert5(typeof factory === "function", "Invalid or no factory specified");
-    assert5(client, "No client specified");
+    assert6(typeof factory === "function", "Invalid or no factory specified");
+    assert6(client, "No client specified");
     this.#factory = factory;
     this.#client = client;
     this.#ttl = ttl;
   }
   async get(key) {
-    const cached = await this.#client.get(key, { ttl: this.#ttl });
-    if (cached)
+    const cached = await this.#client.getc(key);
+    if (cached) {
+      void logPromiseError(this.#client.touch(key), `Factory error touching key "${this.#client.prefix}${key}"`);
       return cached.value;
+    }
     const created = await this.#factory(key);
     if (created) {
       void logPromiseError(this.#client.set(key, created, { ttl: this.#ttl }), `Factory error setting key "${this.#client.prefix}${key}"`);
@@ -1321,8 +1352,8 @@ var Bundle = class {
   #name;
   #ttl;
   constructor(client, name, ttl) {
-    assert5(client, "No client specified");
-    assert5(name, "No bundle name specified");
+    assert6(client, "No client specified");
+    assert6(name, "No bundle name specified");
     this.#client = client;
     this.#name = name;
     this.#ttl = ttl || 0;
@@ -1338,7 +1369,7 @@ var Bundle = class {
   }
   async #removeKey(key) {
     await logPromiseError((async () => {
-      const result = await this.#client.get(this.#name);
+      const result = await this.#client.getc(this.#name);
       if (!result)
         return;
       const keys = result.value.split("\0").filter((k) => k !== key).join("\0");
@@ -1350,7 +1381,7 @@ var Bundle = class {
     await this.#appendKey(key);
   }
   async get(key) {
-    const result = await this.#client.get(`${this.#name}:${key}`);
+    const result = await this.#client.getc(`${this.#name}:${key}`);
     if (result)
       return result.value;
     await this.#removeKey(key);
@@ -1360,13 +1391,13 @@ var Bundle = class {
     await this.#removeKey(key);
   }
   async list() {
-    const result = await this.#client.get(this.#name);
+    const result = await this.#client.getc(this.#name);
     if (!result)
       return {};
     const results = {};
     const promises = [];
     for (const key of new Set(result.value.split("\0"))) {
-      promises.push(this.#client.get(`${this.#name}:${key}`).then((result2) => {
+      promises.push(this.#client.getc(`${this.#name}:${key}`).then((result2) => {
         if (result2)
           results[key] = result2.value;
       }));
@@ -1380,8 +1411,8 @@ var PoorManLock = class {
   #client;
   #name;
   constructor(client, name) {
-    assert5(client, "No client specified");
-    assert5(name, "No lock name specified");
+    assert6(client, "No client specified");
+    assert6(name, "No lock name specified");
     this.#client = client;
     this.#name = name;
   }
@@ -1396,14 +1427,14 @@ var PoorManLock = class {
       await new Promise((resolve) => setTimeout(resolve, 100));
     } while (Date.now() < end);
     if (cas === void 0) {
-      const other = await this.#client.get(this.#name);
+      const other = await this.#client.getc(this.#name);
       const owner2 = other && other.value ? `"${other.value}"` : "anonymous";
       throw new Error(`Lock "${this.#client.prefix}${this.#name}" timeout (owner=${owner2})`);
     }
     const interval = setInterval(() => {
       void logPromiseError((async () => {
         const replaced = await this.#client.replace(this.#name, owner, { ttl: 2, cas });
-        assert5(replaced !== void 0, `Lock "${this.#client.prefix}${this.#name}" not replaced`);
+        assert6(replaced !== void 0, `Lock "${this.#client.prefix}${this.#name}" not replaced`);
         cas = replaced;
       })(), `Error extending lock "${this.#client.prefix}${this.#name}"`);
     }, 100);
@@ -1417,10 +1448,11 @@ var PoorManLock = class {
 };
 export {
   Bundle,
-  Client,
   ClusterAdapter,
   Factory,
   FakeAdapter,
+  MemxClient,
+  MemxFakeClient,
   PoorManLock,
   ServerAdapter,
   connection_exports as connection,