memx 0.0.1 → 0.0.5

package/README.md

@@ -1 +1,2 @@
-
+# MEMX
+Simple and fast memcached client

package/dist/index.js

@@ -21,39 +21,37 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
+  return to;
 };
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Bundle: () => Bundle,
   Client: () => Client,
   ClusterAdapter: () => ClusterAdapter,
+  Factory: () => Factory,
+  FakeAdapter: () => FakeAdapter,
+  PoorManLock: () => PoorManLock,
   ServerAdapter: () => ServerAdapter,
   connection: () => connection_exports,
   constants: () => constants_exports,
   decode: () => decode_exports,
   encode: () => encode_exports
 });
+module.exports = __toCommonJS(src_exports);
 
 // src/decode.ts
 var decode_exports = {};
@@ -316,6 +314,9 @@ function typedArrayFlags(value) {
   const flags = (0, import_types.isUint8Array)(value) ? 3402235920 /* UINT8ARRAY */ : (0, import_types.isUint8ClampedArray)(value) ? 3402235921 /* UINT8CLAMPEDARRAY */ : (0, import_types.isUint16Array)(value) ? 3402235922 /* UINT16ARRAY */ : (0, import_types.isUint32Array)(value) ? 3402235923 /* UINT32ARRAY */ : (0, import_types.isInt8Array)(value) ? 3402235924 /* INT8ARRAY */ : (0, import_types.isInt16Array)(value) ? 3402235925 /* INT16ARRAY */ : (0, import_types.isInt32Array)(value) ? 3402235926 /* INT32ARRAY */ : (0, import_types.isBigUint64Array)(value) ? 3402235927 /* BIGUINT64ARRAY */ : (0, import_types.isBigInt64Array)(value) ? 3402235928 /* BIGINT64ARRAY */ : (0, import_types.isFloat32Array)(value) ? 3402235929 /* FLOAT32ARRAY */ : (0, import_types.isFloat64Array)(value) ? 3402235930 /* FLOAT64ARRAY */ : import_assert2.default.fail("Unsupported kind of TypedArray");
   return flags;
 }
+function logPromiseError(promise, message) {
+  return promise.catch((error) => console.log(message, error)).then(() => void 0);
+}
 
 // src/connection.ts
 var import_assert3 = __toESM(require("assert"));
@@ -459,6 +460,153 @@ 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;
+  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" } };
+  }
+};
+
 // src/server.ts
 var statsBigInt = [
   "auth_cmds",
@@ -606,10 +754,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({
@@ -635,9 +782,15 @@ var ServerAdapter = class {
         fail(response, key);
     }
   }
-  async touch(key, options = {}) {
-    const { ttl = this.#ttl } = options;
-    const keyOffset = this.#buffer.writeUInt32BE(ttl);
+  async get(key) {
+    return this.#get(key);
+  }
+  async gat(key, ttl) {
+    return this.#get(key, ttl || 2592e3);
+  }
+  async touch(key, ttl) {
+    const timeToLive = ttl ?? this.#ttl;
+    const keyOffset = this.#buffer.writeUInt32BE(timeToLive);
     const keyLength = this.#writeKey(key, keyOffset);
     const [response] = await this.#connection.send({
       opcode: 28 /* TOUCH */,
@@ -884,6 +1037,7 @@ var ServerAdapter = class {
 };
 
 // src/cluster.ts
+var import_assert4 = __toESM(require("assert"));
 function parseHosts(hosts) {
   const result = [];
   if (!hosts)
@@ -897,6 +1051,7 @@ function parseHosts(hosts) {
 }
 var ClusterAdapter = class {
   servers;
+  ttl;
   constructor(serversOrOptions) {
     if (Array.isArray(serversOrOptions)) {
       this.servers = [...serversOrOptions];
@@ -924,6 +1079,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) => {
+      import_assert4.default.equal(server.ttl, this.ttl, `TTL Mismatch (${server.ttl} != ${this.ttl})`);
+    });
     Object.freeze(this.servers);
   }
   server(key) {
@@ -933,11 +1092,14 @@ 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);
   }
-  touch(key, options) {
-    return this.server(key).touch(key, options);
+  gat(key, ttl) {
+    return this.server(key).gat(key, ttl);
+  }
+  touch(key, ttl) {
+    return this.server(key).touch(key, ttl);
   }
   set(key, value, options) {
     return this.server(key).set(key, value, options);
@@ -983,8 +1145,34 @@ var ClusterAdapter = class {
 };
 
 // src/client.ts
-var import_assert4 = __toESM(require("assert"));
-var import_types4 = require("util/types");
+var import_assert5 = __toESM(require("assert"));
+var import_types5 = require("util/types");
+function replacer(key, value) {
+  if (typeof this[key] === "bigint")
+    return ["\0__$BIGINT$__\0", this[key].toString()];
+  if (this[key] instanceof Date)
+    return ["\0__$DATE$__\0", this[key].toISOString()];
+  if (this[key] instanceof Set)
+    return ["\0__$SET$__\0", ...value];
+  if (this[key] instanceof Map)
+    return ["\0__$MAP$__\0", ...value.entries()];
+  return value;
+}
+function reviver(key, value) {
+  if (Array.isArray(value)) {
+    switch (value[0]) {
+      case "\0__$BIGINT$__\0":
+        return BigInt(value[1]);
+      case "\0__$DATE$__\0":
+        return new Date(value[1]);
+      case "\0__$SET$__\0":
+        return new Set(value.slice(1));
+      case "\0__$MAP$__\0":
+        return new Map(value.slice(1));
+    }
+  }
+  return value;
+}
 function toBuffer(value, options) {
   if (Buffer.isBuffer(value))
     return [value, __spreadProps(__spreadValues({}, options), { flags: 0 /* BUFFER */ })];
@@ -1000,24 +1188,72 @@ function toBuffer(value, options) {
     case "object":
       break;
     default:
-      import_assert4.default.fail(`Unable to store value of type "${typeof value}"`);
+      import_assert5.default.fail(`Unable to store value of type "${typeof value}"`);
   }
-  if ((0, import_types4.isTypedArray)(value)) {
+  if ((0, import_types5.isTypedArray)(value)) {
     const flags = typedArrayFlags(value);
     const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
     return [buffer, __spreadProps(__spreadValues({}, options), { flags })];
   }
   if (value === null)
     return [EMPTY_BUFFER, __spreadProps(__spreadValues({}, options), { flags: 3402235918 /* NULL */ })];
-  return [Buffer.from(JSON.stringify(value), "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
+  const json = JSON.stringify(value, replacer);
+  return [Buffer.from(json, "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
 }
-function makeTypedArray(constructor, source, bytesPerValue) {
+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 / bytesPerValue);
+  return new constructor(buffer, byteOffset, byteLength / constructor.BYTES_PER_ELEMENT);
 }
 var Client = class {
   #adapter;
+  #prefix;
   constructor(adapterOrOptions) {
     if (!adapterOrOptions) {
       this.#adapter = new ClusterAdapter();
@@ -1026,96 +1262,73 @@ var Client = class {
     } else if ("hosts" in adapterOrOptions) {
       this.#adapter = new ClusterAdapter(adapterOrOptions);
     }
-    (0, import_assert4.default)(this.#adapter, "Invalid client constructor arguments");
+    this.#prefix = "";
+    (0, import_assert5.default)(this.#adapter, "Invalid client constructor arguments");
   }
   get adapter() {
     return this.#adapter;
   }
-  async get(key, options) {
-    const result = await this.#adapter.get(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")), cas };
-        case 3402235920 /* UINT8ARRAY */:
-          return { value: makeTypedArray(Uint8Array, value, 1), cas };
-        case 3402235921 /* UINT8CLAMPEDARRAY */:
-          return { value: makeTypedArray(Uint8ClampedArray, value, 1), cas };
-        case 3402235922 /* UINT16ARRAY */:
-          return { value: makeTypedArray(Uint16Array, value, 2), cas };
-        case 3402235923 /* UINT32ARRAY */:
-          return { value: makeTypedArray(Uint32Array, value, 4), cas };
-        case 3402235924 /* INT8ARRAY */:
-          return { value: makeTypedArray(Int8Array, value, 1), cas };
-        case 3402235925 /* INT16ARRAY */:
-          return { value: makeTypedArray(Int16Array, value, 2), cas };
-        case 3402235926 /* INT32ARRAY */:
-          return { value: makeTypedArray(Int32Array, value, 4), cas };
-        case 3402235927 /* BIGUINT64ARRAY */:
-          return { value: makeTypedArray(BigUint64Array, value, 8), cas };
-        case 3402235928 /* BIGINT64ARRAY */:
-          return { value: makeTypedArray(BigInt64Array, value, 8), cas };
-        case 3402235929 /* FLOAT32ARRAY */:
-          return { value: makeTypedArray(Float32Array, value, 4), cas };
-        case 3402235930 /* FLOAT64ARRAY */:
-          return { value: makeTypedArray(Float64Array, value, 8), cas };
-        case 0 /* BUFFER */:
-        default:
-          return { value: Buffer.from(value), cas };
-      }
-    } finally {
-      result.recycle();
-    }
+  get prefix() {
+    return this.#prefix;
+  }
+  withPrefix(prefix) {
+    (0, import_assert5.default)(prefix, "Invalid prefix");
+    const client = new Client(this.#adapter);
+    client.#prefix = prefix;
+    return client;
+  }
+  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(key, ...toBuffer(value, options));
+    return this.#adapter.set(this.#prefix + key, ...toBuffer(value, options));
   }
   async add(key, value, options) {
-    return this.#adapter.add(key, ...toBuffer(value, options));
+    return this.#adapter.add(this.#prefix + key, ...toBuffer(value, options));
   }
   async replace(key, value, options) {
-    return this.#adapter.replace(key, ...toBuffer(value, options));
+    return this.#adapter.replace(this.#prefix + key, ...toBuffer(value, options));
   }
   append(key, value, options) {
-    return this.#adapter.append(key, ...toBuffer(value, options));
+    return this.#adapter.append(this.#prefix + key, ...toBuffer(value, options));
   }
   prepend(key, value, options) {
-    return this.#adapter.prepend(key, ...toBuffer(value, options));
+    return this.#adapter.prepend(this.#prefix + key, ...toBuffer(value, options));
   }
   async increment(key, delta, options) {
-    const counter = await this.#adapter.increment(key, delta, options);
-    if (counter && options && options.initial !== void 0 && counter.value === BigInt(options.initial)) {
+    const counter = await this.#adapter.increment(this.#prefix + key, delta, options);
+    if ((options == null ? void 0 : options.initial) !== void 0 && (counter == null ? void 0 : counter.value) === BigInt(options.initial)) {
       const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl });
       counter.cas = cas ?? counter.cas;
     }
     return counter;
   }
   async decrement(key, delta, options) {
-    const counter = await this.#adapter.decrement(key, delta, options);
-    if (counter && options && options.initial !== void 0 && counter.value === BigInt(options.initial)) {
+    const counter = await this.#adapter.decrement(this.#prefix + key, delta, options);
+    if ((options == null ? void 0 : options.initial) !== void 0 && (counter == null ? void 0 : counter.value) === BigInt(options.initial)) {
       const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl });
       counter.cas = cas ?? counter.cas;
     }
     return counter;
   }
-  touch(key, options) {
-    return this.#adapter.touch(key, options);
+  touch(key, ttl) {
+    return this.#adapter.touch(this.#prefix + key, ttl);
   }
   delete(key, options) {
-    return this.#adapter.delete(key, options);
+    return this.#adapter.delete(this.#prefix + key, options);
   }
   flush(ttl) {
     return this.#adapter.flush(ttl);
@@ -1133,11 +1346,140 @@ var Client = class {
     return this.#adapter.stats();
   }
 };
-module.exports = __toCommonJS(src_exports);
+
+// src/utils.ts
+var import_assert6 = __toESM(require("assert"));
+var Factory = class {
+  #factory;
+  #client;
+  #ttl;
+  constructor(client, factory, ttl) {
+    (0, import_assert6.default)(typeof factory === "function", "Invalid or no factory specified");
+    (0, import_assert6.default)(client, "No client specified");
+    this.#factory = factory;
+    this.#client = client;
+    this.#ttl = ttl;
+  }
+  async get(key) {
+    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}"`);
+    }
+    return created;
+  }
+};
+var Bundle = class {
+  #client;
+  #name;
+  #ttl;
+  constructor(client, name, ttl) {
+    (0, import_assert6.default)(client, "No client specified");
+    (0, import_assert6.default)(name, "No bundle name specified");
+    this.#client = client;
+    this.#name = name;
+    this.#ttl = ttl || 0;
+  }
+  async #appendKey(key) {
+    await logPromiseError((async () => {
+      const added = await this.#client.add(this.#name, key, { ttl: this.#ttl });
+      if (!added) {
+        await this.#client.append(this.#name, `\0${key}`);
+        await this.#client.touch(this.#name, this.#ttl);
+      }
+    })(), `Bundle "${this.#client.prefix}${this.#name}" error recording key "${key}"`);
+  }
+  async #removeKey(key) {
+    await logPromiseError((async () => {
+      const result = await this.#client.getc(this.#name);
+      if (!result)
+        return;
+      const keys = result.value.split("\0").filter((k) => k !== key).join("\0");
+      await this.#client.set(this.#name, keys, { cas: result.cas, ttl: this.#ttl });
+    })(), `Bundle "${this.#client.prefix}${this.#name}" error clearing key "${key}"`);
+  }
+  async add(key, value) {
+    await this.#client.set(`${this.#name}:${key}`, value, { ttl: this.#ttl });
+    await this.#appendKey(key);
+  }
+  async get(key) {
+    const result = await this.#client.getc(`${this.#name}:${key}`);
+    if (result)
+      return result.value;
+    await this.#removeKey(key);
+  }
+  async delete(key) {
+    await this.#client.delete(`${this.#name}:${key}`);
+    await this.#removeKey(key);
+  }
+  async list() {
+    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.getc(`${this.#name}:${key}`).then((result2) => {
+        if (result2)
+          results[key] = result2.value;
+      }));
+    }
+    await Promise.all(promises);
+    await logPromiseError(this.#client.set(this.#name, Object.keys(results).join("\0"), { cas: result.cas, ttl: this.#ttl }), `Bundle "${this.#client.prefix}${this.#name}" error compacting keys`);
+    return results;
+  }
+};
+var PoorManLock = class {
+  #client;
+  #name;
+  constructor(client, name) {
+    (0, import_assert6.default)(client, "No client specified");
+    (0, import_assert6.default)(name, "No lock name specified");
+    this.#client = client;
+    this.#name = name;
+  }
+  async execute(executor, options) {
+    const { timeout = 5e3, owner = false } = options || {};
+    const end = Date.now() + timeout;
+    let cas;
+    do {
+      cas = await this.#client.add(this.#name, owner, { ttl: 2 });
+      if (cas !== void 0)
+        break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } while (Date.now() < end);
+    if (cas === void 0) {
+      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 });
+        (0, import_assert6.default)(replaced !== void 0, `Lock "${this.#client.prefix}${this.#name}" not replaced`);
+        cas = replaced;
+      })(), `Error extending lock "${this.#client.prefix}${this.#name}"`);
+    }, 100);
+    try {
+      return await executor();
+    } finally {
+      clearInterval(interval);
+      await logPromiseError(this.#client.delete(this.#name, { cas }), `Error deleting lock "${this.#client.prefix}${this.#name}"`);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Bundle,
   Client,
   ClusterAdapter,
+  Factory,
+  FakeAdapter,
+  PoorManLock,
   ServerAdapter,
   connection,
   constants,