@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/replication/coordinator/etcd.mjs

@@ -1,183 +1,312 @@
 import { compatibilityAllowsPromotion } from '../../chunk-ER7ODTDA.mjs';
-import { CoordinatorError, NoSafePrimaryError } from '../../chunk-H5AB6NIR.mjs';
-import '../../chunk-YPYVQJ4C.mjs';
+import { CoordinatorError, NoSafePrimaryError } from '../../chunk-O7SLN3GI.mjs';
+import '../../chunk-5NOIGN5Y.mjs';
+import '../../chunk-UC3SCMIN.mjs';
 import { Etcd3 } from 'etcd3';
 
+// src/replication/coordinator/group-rules.ts
 var MIN_AUTOMATIC_FAILOVER_VOTERS = 3;
-var EtcdClusterCoordinator = class {
-  client;
-  namespace;
-  onWatcherError;
-  leases = /* @__PURE__ */ new Map();
-  watchers = /* @__PURE__ */ new Set();
-  constructor(options) {
-    assertEtcdOptions(options);
-    this.client = new Etcd3(toEtcdOptions(options));
-    this.namespace = this.client.namespace(normaliseKeyPrefix(options.keyPrefix));
-    this.onWatcherError = options.onWatcherError;
+function assertNonEmpty(value, name) {
+  if (value.length === 0) {
+    throw new TypeError(`${name} must not be empty`);
   }
-  async tryAcquireControllerLease(input) {
-    assertNonEmpty(input.clusterId, "clusterId");
-    assertNonEmpty(input.holderId, "holderId");
-    assertPositiveTtl(input.ttlMs);
-    const key = controllerLeaseKey(input.clusterId);
-    const lease = this.namespace.lease(ttlMsToSeconds(input.ttlMs));
-    const leaseId = await lease.grant();
-    const grantedAtMs = Date.now();
-    const value = serializeLease({
-      id: leaseId,
-      kind: "controller",
-      clusterId: input.clusterId,
-      holderId: input.holderId,
-      ttlMs: input.ttlMs,
-      grantedAtMs,
-      expiresAtMs: grantedAtMs + input.ttlMs,
-      metadata: cloneMetadata(input.metadata)
-    });
-    const result = await this.namespace.if(key, "Create", "==", 0).then(this.namespace.put(key).value(value).lease(leaseId)).commit();
-    if (!result.succeeded) {
-      await revokeLeaseQuietly(lease);
-      const current = await this.getLeaseFromKey(key);
-      return { acquired: false, lease: current };
-    }
-    this.trackLease(lease, {
-      leaseId,
-      key,
-      ttlMs: input.ttlMs,
-      ttlSeconds: ttlMsToSeconds(input.ttlMs),
-      kind: "controller",
-      clusterId: input.clusterId,
-      holderId: input.holderId,
-      metadata: cloneMetadata(input.metadata)
-    });
-    const parsed = parseLease(value);
-    return { acquired: true, lease: parsed };
+}
+function assertPositiveTtl(ttlMs) {
+  if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0) {
+    throw new RangeError("ttlMs must be a positive safe integer");
   }
-  async renewLease(leaseId, ttlMs) {
-    assertNonEmpty(leaseId, "leaseId");
-    assertPositiveTtl(ttlMs);
-    const entry = this.leases.get(leaseId);
-    if (!entry) {
-      return false;
-    }
-    try {
-      await entry.lease.keepaliveOnce();
-      const renewedAtMs = Date.now();
-      const leaseValue = {
-        id: leaseId,
-        kind: entry.kind,
-        clusterId: entry.clusterId,
-        holderId: entry.holderId,
-        ttlMs,
-        grantedAtMs: renewedAtMs,
-        expiresAtMs: renewedAtMs + ttlMs,
-        metadata: cloneMetadata(entry.metadata)
-      };
-      const value = entry.kind === "node-session" && entry.nodeSession ? JSON.stringify({ ...entry.nodeSession, lease: leaseValue }) : serializeLease(leaseValue);
-      await this.namespace.put(entry.key).value(value).ignoreLease();
-      entry.ttlMs = ttlMs;
-      return true;
-    } catch {
-      this.leases.delete(leaseId);
-      return false;
+}
+function assertNonNegativeTerm(term) {
+  if (term < 0n) {
+    throw new RangeError("primaryTerm must not be negative");
+  }
+}
+function assertNonNegativeSeq(seq, name) {
+  if (seq < 0n) {
+    throw new RangeError(`${name} must not be negative`);
+  }
+}
+function assertSubset(values, allowed, name) {
+  const allowedSet = new Set(allowed);
+  for (const value of values) {
+    if (!allowedSet.has(value)) {
+      throw new RangeError(`${name} contains node id '${value}' that is not configured for the replication group`);
     }
   }
-  async releaseLease(leaseId) {
-    assertNonEmpty(leaseId, "leaseId");
-    const entry = this.leases.get(leaseId);
-    if (!entry) {
-      return false;
+}
+function assertPrimaryInGroup(primary, votingDataBearingNodeIds) {
+  if (!primary) return;
+  assertNonEmpty(primary.nodeId, "primary.nodeId");
+  if (!votingDataBearingNodeIds.includes(primary.nodeId)) {
+    throw new RangeError(`Primary node '${primary.nodeId}' is not configured for the replication group`);
+  }
+}
+function assertNoInSyncAdditions(previous, next) {
+  const previousSet = new Set(previous);
+  for (const nodeId of next) {
+    if (!previousSet.has(nodeId)) {
+      throw new RangeError(`Node '${nodeId}' cannot be added to the in-sync set without catch-up proof`);
     }
-    this.leases.delete(leaseId);
-    const currentValue = await this.namespace.get(entry.key).string();
-    const currentLeaseId = currentValue ? parseLeaseIdForEntry(entry.kind, currentValue) : null;
-    let released = false;
-    if (currentLeaseId === leaseId && currentValue) {
-      const result = await this.namespace.if(entry.key, "Value", "==", currentValue).then(this.namespace.delete().key(entry.key)).commit();
-      released = result.succeeded === true;
+  }
+}
+function normaliseNodeIds(nodeIds, name) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const nodeId of nodeIds) {
+    assertNonEmpty(nodeId, `${name} entry`);
+    if (seen.has(nodeId)) {
+      throw new RangeError(`${name} contains duplicate node id '${nodeId}'`);
     }
-    await revokeLeaseQuietly(entry.lease);
-    return released;
+    seen.add(nodeId);
+    result.push(nodeId);
   }
-  async registerNodeSession(input) {
-    assertNonEmpty(input.clusterId, "clusterId");
-    assertNonEmpty(input.nodeId, "nodeId");
-    assertPositiveTtl(input.ttlMs);
-    const key = nodeSessionKey(input.clusterId, input.nodeId);
-    const existingRawSession = await this.namespace.get(key).string();
-    if (existingRawSession) {
-      const existingSession = parseNodeSession(existingRawSession);
-      if (existingSession.lease.expiresAtMs > Date.now()) {
-        throw new CoordinatorError(`Node session '${input.nodeId}' is already registered`);
-      }
+  return result;
+}
+function setMembership(values, nodeId, enabled) {
+  if (enabled === void 0) return values;
+  const next = values.filter((value) => value !== nodeId);
+  if (enabled) {
+    next.push(nodeId);
+  }
+  return next;
+}
+function removeNodeId(values, nodeId) {
+  return values.filter((value) => value !== nodeId);
+}
+function arraysEqual(left, right) {
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+function markDisplacedPrimaryForRepair(state, displacedPrimaryId, nextPrimaryId) {
+  if (!displacedPrimaryId || displacedPrimaryId === nextPrimaryId) return;
+  state.inSyncNodeIds = removeNodeId(state.inSyncNodeIds, displacedPrimaryId);
+  state.repairingNodeIds = setMembership(state.repairingNodeIds, displacedPrimaryId, true);
+}
+function cloneCompatibility(compatibility) {
+  return compatibility ? { ...compatibility } : void 0;
+}
+function cloneMetadata(metadata) {
+  return metadata ? { ...metadata } : void 0;
+}
+function isEligiblePromotionSession(state, nodeId, session) {
+  if (!session) {
+    return false;
+  }
+  return session.dataBearing && session.voting && state.inSyncNodeIds.includes(nodeId) && compatibilityAllowsPromotion(state.compatibility, session.compatibility) && !state.drainingNodeIds.includes(nodeId) && !state.repairingNodeIds.includes(nodeId) && !state.faultedNodeIds.includes(nodeId);
+}
+function nextInSyncSetState(state, input, nowMs) {
+  const inSyncNodeIds = normaliseNodeIds(input.inSyncNodeIds, "inSyncNodeIds");
+  assertSubset(inSyncNodeIds, state.votingDataBearingNodeIds, "inSyncNodeIds");
+  assertNoInSyncAdditions(state.inSyncNodeIds, inSyncNodeIds);
+  const durabilityPointSeq = input.durabilityPointSeq !== void 0 && input.durabilityPointSeq > state.durabilityPointSeq ? input.durabilityPointSeq : state.durabilityPointSeq;
+  if (arraysEqual(inSyncNodeIds, state.inSyncNodeIds) && durabilityPointSeq === state.durabilityPointSeq) {
+    return state;
+  }
+  return { ...state, durabilityPointSeq, inSyncNodeIds, updatedAtMs: nowMs };
+}
+function nextAdmittedInSyncState(state, input, nowMs) {
+  assertNodeInGroup(state, input.nodeId);
+  if (state.currentPrimary?.nodeId !== input.sourceNodeId || state.drainingNodeIds.includes(input.nodeId) || state.faultedNodeIds.includes(input.nodeId) || input.appliedSeq < state.durabilityPointSeq) {
+    return state;
+  }
+  const inSyncNodeIds = state.inSyncNodeIds.includes(input.nodeId) ? state.inSyncNodeIds : [...state.inSyncNodeIds, input.nodeId];
+  const repairingNodeIds = removeNodeId(state.repairingNodeIds, input.nodeId);
+  if (arraysEqual(inSyncNodeIds, state.inSyncNodeIds) && arraysEqual(repairingNodeIds, state.repairingNodeIds)) {
+    return state;
+  }
+  return { ...state, inSyncNodeIds, repairingNodeIds, updatedAtMs: nowMs };
+}
+function nextMaintenanceState(state, input, nowMs) {
+  assertNodeInGroup(state, input.nodeId);
+  const leavingService = input.draining === true || input.repairing === true || input.faulted === true;
+  return {
+    ...state,
+    drainingNodeIds: setMembership(state.drainingNodeIds, input.nodeId, input.draining),
+    repairingNodeIds: setMembership(state.repairingNodeIds, input.nodeId, input.repairing),
+    faultedNodeIds: setMembership(state.faultedNodeIds, input.nodeId, input.faulted),
+    inSyncNodeIds: leavingService ? removeNodeId(state.inSyncNodeIds, input.nodeId) : state.inSyncNodeIds,
+    updatedAtMs: nowMs
+  };
+}
+function assertNodeInGroup(state, nodeId) {
+  if (!state.votingDataBearingNodeIds.includes(nodeId)) {
+    throw new RangeError(`Node '${nodeId}' is not configured for the replication group`);
+  }
+}
+function buildReplicationGroupState(input, nowMs = Date.now()) {
+  assertNonEmpty(input.clusterId, "clusterId");
+  assertNonEmpty(input.groupId, "groupId");
+  const votingDataBearingNodeIds = normaliseNodeIds(input.votingDataBearingNodeIds, "votingDataBearingNodeIds");
+  const inSyncNodeIds = normaliseNodeIds(input.inSyncNodeIds ?? [], "inSyncNodeIds");
+  const drainingNodeIds = normaliseNodeIds(input.drainingNodeIds ?? [], "drainingNodeIds");
+  const repairingNodeIds = normaliseNodeIds(input.repairingNodeIds ?? [], "repairingNodeIds");
+  const faultedNodeIds = normaliseNodeIds(input.faultedNodeIds ?? [], "faultedNodeIds");
+  assertNonNegativeTerm(input.primaryTerm ?? 0n);
+  assertNonNegativeSeq(input.durabilityPointSeq ?? 0n, "durabilityPointSeq");
+  assertPrimaryInGroup(input.currentPrimary ?? null, votingDataBearingNodeIds);
+  assertSubset(inSyncNodeIds, votingDataBearingNodeIds, "inSyncNodeIds");
+  assertSubset(drainingNodeIds, votingDataBearingNodeIds, "drainingNodeIds");
+  assertSubset(repairingNodeIds, votingDataBearingNodeIds, "repairingNodeIds");
+  assertSubset(faultedNodeIds, votingDataBearingNodeIds, "faultedNodeIds");
+  return {
+    clusterId: input.clusterId,
+    groupId: input.groupId,
+    votingDataBearingNodeIds,
+    currentPrimary: input.currentPrimary ? { ...input.currentPrimary } : null,
+    primaryTerm: input.primaryTerm ?? 0n,
+    durabilityPointSeq: input.durabilityPointSeq ?? 0n,
+    inSyncNodeIds,
+    drainingNodeIds,
+    repairingNodeIds,
+    faultedNodeIds,
+    compatibility: cloneCompatibility(input.compatibility),
+    updatedAtMs: nowMs
+  };
+}
+function cloneReplicationGroupState(state) {
+  return {
+    ...state,
+    currentPrimary: state.currentPrimary ? { ...state.currentPrimary } : null,
+    votingDataBearingNodeIds: [...state.votingDataBearingNodeIds],
+    durabilityPointSeq: state.durabilityPointSeq,
+    inSyncNodeIds: [...state.inSyncNodeIds],
+    drainingNodeIds: [...state.drainingNodeIds],
+    repairingNodeIds: [...state.repairingNodeIds],
+    faultedNodeIds: [...state.faultedNodeIds],
+    compatibility: cloneCompatibility(state.compatibility)
+  };
+}
+
+// src/replication/coordinator/etcd-codec.ts
+function serializeLease(lease) {
+  return JSON.stringify(lease);
+}
+function parseLease(raw) {
+  const value = JSON.parse(raw);
+  return {
+    ...value,
+    metadata: cloneMetadata(value.metadata)
+  };
+}
+function parseNodeSession(raw) {
+  const value = JSON.parse(raw);
+  return {
+    ...value,
+    lease: parseLease(JSON.stringify(value.lease)),
+    groupIds: [...value.groupIds],
+    compatibility: cloneCompatibility(value.compatibility),
+    metadata: cloneMetadata(value.metadata)
+  };
+}
+function parseLeaseIdForEntry(kind, raw) {
+  try {
+    if (kind === "node-session") {
+      return parseNodeSession(raw).lease.id;
     }
-    const lease = this.namespace.lease(ttlMsToSeconds(input.ttlMs));
-    const leaseId = await lease.grant();
-    const grantedAtMs = Date.now();
-    const session = {
-      clusterId: input.clusterId,
-      nodeId: input.nodeId,
-      lease: {
-        id: leaseId,
-        kind: "node-session",
-        clusterId: input.clusterId,
-        holderId: input.nodeId,
-        ttlMs: input.ttlMs,
-        grantedAtMs,
-        expiresAtMs: grantedAtMs + input.ttlMs,
-        metadata: cloneMetadata(input.metadata)
-      },
-      endpoint: input.endpoint,
-      groupIds: [...input.groupIds ?? []],
-      dataBearing: input.dataBearing ?? true,
-      voting: input.voting ?? true,
-      compatibility: cloneCompatibility(input.compatibility),
-      metadata: cloneMetadata(input.metadata)
-    };
-    const rawSession = JSON.stringify(session);
-    const transaction = existingRawSession ? this.namespace.if(key, "Value", "==", existingRawSession) : this.namespace.if(key, "Create", "==", 0);
-    const result = await transaction.then(this.namespace.put(key).value(rawSession).lease(leaseId)).commit();
-    if (!result.succeeded) {
-      await revokeLeaseQuietly(lease);
-      throw new CoordinatorError(`Node session '${input.nodeId}' registration conflicted with a concurrent write`);
+    return parseLease(raw).id;
+  } catch {
+    return null;
+  }
+}
+function serializeGroupState(state) {
+  const serialized = {
+    ...state,
+    currentPrimary: state.currentPrimary ? { ...state.currentPrimary } : null,
+    votingDataBearingNodeIds: [...state.votingDataBearingNodeIds],
+    primaryTerm: state.primaryTerm.toString(),
+    durabilityPointSeq: state.durabilityPointSeq.toString(),
+    inSyncNodeIds: [...state.inSyncNodeIds],
+    drainingNodeIds: [...state.drainingNodeIds],
+    repairingNodeIds: [...state.repairingNodeIds],
+    faultedNodeIds: [...state.faultedNodeIds],
+    compatibility: cloneCompatibility(state.compatibility)
+  };
+  return JSON.stringify(serialized);
+}
+function parseGroupState(raw) {
+  const value = JSON.parse(raw);
+  return {
+    ...value,
+    currentPrimary: value.currentPrimary ? { ...value.currentPrimary } : null,
+    votingDataBearingNodeIds: [...value.votingDataBearingNodeIds],
+    primaryTerm: BigInt(value.primaryTerm),
+    durabilityPointSeq: value.durabilityPointSeq !== void 0 ? BigInt(value.durabilityPointSeq) : 0n,
+    inSyncNodeIds: [...value.inSyncNodeIds],
+    drainingNodeIds: [...value.drainingNodeIds],
+    repairingNodeIds: [...value.repairingNodeIds],
+    faultedNodeIds: [...value.faultedNodeIds ?? []],
+    compatibility: cloneCompatibility(value.compatibility)
+  };
+}
+
+// src/replication/coordinator/etcd-connection.ts
+function assertEtcdOptions(options) {
+  const hosts = Array.isArray(options.hosts) ? options.hosts : [options.hosts];
+  if (hosts.length === 0) {
+    throw new TypeError("hosts must contain at least one etcd endpoint");
+  }
+  for (const host of hosts) {
+    assertNonEmpty(host, "hosts entry");
+    if (!options.allowInsecure && !host.startsWith("https://")) {
+      throw new TypeError("production coordinator access requires https etcd endpoints");
     }
-    this.trackLease(lease, {
-      leaseId,
-      key,
-      ttlMs: input.ttlMs,
-      ttlSeconds: ttlMsToSeconds(input.ttlMs),
-      kind: "node-session",
-      clusterId: input.clusterId,
-      holderId: input.nodeId,
-      metadata: cloneMetadata(input.metadata),
-      nodeSession: {
-        clusterId: session.clusterId,
-        nodeId: session.nodeId,
-        endpoint: session.endpoint,
-        groupIds: [...session.groupIds],
-        dataBearing: session.dataBearing,
-        voting: session.voting,
-        compatibility: cloneCompatibility(session.compatibility),
-        metadata: cloneMetadata(session.metadata)
-      }
-    });
-    return parseNodeSession(rawSession);
   }
-  async getLiveNodeSession(clusterId, nodeId) {
-    assertNonEmpty(clusterId, "clusterId");
-    assertNonEmpty(nodeId, "nodeId");
-    const value = await this.namespace.get(nodeSessionKey(clusterId, nodeId)).string();
-    return value ? parseNodeSession(value) : null;
+  assertNonEmpty(options.keyPrefix, "keyPrefix");
+  if (!options.allowInsecure && !options.credentials) {
+    throw new TypeError("production coordinator access requires TLS credentials");
+  }
+  const hasMtlsIdentity = Boolean(options.credentials?.privateKey && options.credentials.certChain);
+  const hasPasswordAuth = Boolean(options.auth?.username && options.auth.password);
+  if (!options.allowInsecure && !hasMtlsIdentity && !hasPasswordAuth) {
+    throw new TypeError("production coordinator access requires an authenticated Sirannon identity");
+  }
+}
+function toEtcdOptions(options) {
+  const defaultCallTimeoutMs = options.defaultCallTimeoutMs;
+  const defaultCallOptions = defaultCallTimeoutMs ? () => ({ deadline: Date.now() + defaultCallTimeoutMs }) : void 0;
+  return {
+    hosts: options.hosts,
+    credentials: options.credentials,
+    auth: options.auth,
+    grpcOptions: options.grpcOptions,
+    dialTimeout: options.dialTimeoutMs,
+    defaultCallOptions
+  };
+}
+function normaliseKeyPrefix(prefix) {
+  const trimmed = prefix.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (trimmed.length === 0) {
+    throw new TypeError("keyPrefix must not resolve to the etcd root");
   }
-  async deregisterNodeSession(clusterId, nodeId) {
-    assertNonEmpty(clusterId, "clusterId");
-    assertNonEmpty(nodeId, "nodeId");
-    const key = nodeSessionKey(clusterId, nodeId);
-    for (const [leaseId, entry] of this.leases) {
-      if (entry.key === key) {
-        await this.releaseLease(leaseId);
-      }
-    }
+  return `${trimmed}/`;
+}
+function controllerLeaseKey(clusterId) {
+  return `clusters/${encodeKey(clusterId)}/controller`;
+}
+function nodeSessionKey(clusterId, nodeId) {
+  return `clusters/${encodeKey(clusterId)}/nodes/${encodeKey(nodeId)}`;
+}
+function replicationGroupKey(clusterId, groupId) {
+  return `clusters/${encodeKey(clusterId)}/groups/${encodeKey(groupId)}`;
+}
+function ttlMsToSeconds(ttlMs) {
+  return Math.max(1, Math.ceil(ttlMs / 1e3));
+}
+function encodeKey(value) {
+  return encodeURIComponent(value);
+}
+
+// src/replication/coordinator/etcd-group-store.ts
+var MAX_CAS_ATTEMPTS = 5;
+var MAX_PROMOTION_ATTEMPTS = 3;
+var EtcdGroupStore = class {
+  constructor(namespace, watchers, onWatcherError) {
+    this.namespace = namespace;
+    this.watchers = watchers;
+    this.onWatcherError = onWatcherError;
   }
   async setReplicationGroupState(input) {
     const state = buildReplicationGroupState(input);
@@ -247,16 +376,12 @@ var EtcdClusterCoordinator = class {
     if (input.durabilityPointSeq !== void 0) {
       assertNonNegativeSeq(input.durabilityPointSeq, "durabilityPointSeq");
     }
-    const inSyncNodeIds = normaliseNodeIds(input.inSyncNodeIds, "inSyncNodeIds");
-    return this.updateGroupStateWithRetry(input.clusterId, input.groupId, (state) => {
-      assertSubset(inSyncNodeIds, state.votingDataBearingNodeIds, "inSyncNodeIds");
-      assertNoInSyncAdditions(state.inSyncNodeIds, inSyncNodeIds);
-      const durabilityPointSeq = input.durabilityPointSeq !== void 0 && input.durabilityPointSeq > state.durabilityPointSeq ? input.durabilityPointSeq : state.durabilityPointSeq;
-      if (arraysEqual(inSyncNodeIds, state.inSyncNodeIds) && durabilityPointSeq === state.durabilityPointSeq) {
-        return state;
-      }
-      return { ...state, durabilityPointSeq, inSyncNodeIds, updatedAtMs: Date.now() };
-    });
+    normaliseNodeIds(input.inSyncNodeIds, "inSyncNodeIds");
+    return this.updateGroupStateWithRetry(
+      input.clusterId,
+      input.groupId,
+      (state) => nextInSyncSetState(state, input, Date.now())
+    );
   }
   async admitNodeToInSyncSet(input) {
     assertNonEmpty(input.clusterId, "clusterId");
@@ -264,44 +389,27 @@ var EtcdClusterCoordinator = class {
     assertNonEmpty(input.nodeId, "nodeId");
     assertNonEmpty(input.sourceNodeId, "sourceNodeId");
     assertNonNegativeSeq(input.appliedSeq, "appliedSeq");
-    return this.updateGroupStateWithRetry(input.clusterId, input.groupId, (state) => {
-      if (!state.votingDataBearingNodeIds.includes(input.nodeId)) {
-        throw new RangeError(`Node '${input.nodeId}' is not configured for the replication group`);
-      }
-      if (state.currentPrimary?.nodeId !== input.sourceNodeId || state.drainingNodeIds.includes(input.nodeId) || state.faultedNodeIds.includes(input.nodeId) || input.appliedSeq < state.durabilityPointSeq) {
-        return state;
-      }
-      const inSyncNodeIds = state.inSyncNodeIds.includes(input.nodeId) ? state.inSyncNodeIds : [...state.inSyncNodeIds, input.nodeId];
-      const repairingNodeIds = removeNodeId(state.repairingNodeIds, input.nodeId);
-      if (arraysEqual(inSyncNodeIds, state.inSyncNodeIds) && arraysEqual(repairingNodeIds, state.repairingNodeIds)) {
-        return state;
-      }
-      return { ...state, inSyncNodeIds, repairingNodeIds, updatedAtMs: Date.now() };
-    });
+    return this.updateGroupStateWithRetry(
+      input.clusterId,
+      input.groupId,
+      (state) => nextAdmittedInSyncState(state, input, Date.now())
+    );
   }
   async updateNodeMaintenance(input) {
     assertNonEmpty(input.clusterId, "clusterId");
     assertNonEmpty(input.groupId, "groupId");
     assertNonEmpty(input.nodeId, "nodeId");
-    return this.updateGroupStateWithRetry(input.clusterId, input.groupId, (state) => {
-      if (!state.votingDataBearingNodeIds.includes(input.nodeId)) {
-        throw new RangeError(`Node '${input.nodeId}' is not configured for the replication group`);
-      }
-      return {
-        ...state,
-        drainingNodeIds: setMembership(state.drainingNodeIds, input.nodeId, input.draining),
-        repairingNodeIds: setMembership(state.repairingNodeIds, input.nodeId, input.repairing),
-        faultedNodeIds: setMembership(state.faultedNodeIds, input.nodeId, input.faulted),
-        inSyncNodeIds: input.draining === true || input.repairing === true || input.faulted === true ? removeNodeId(state.inSyncNodeIds, input.nodeId) : state.inSyncNodeIds,
-        updatedAtMs: Date.now()
-      };
-    });
+    return this.updateGroupStateWithRetry(
+      input.clusterId,
+      input.groupId,
+      (state) => nextMaintenanceState(state, input, Date.now())
+    );
   }
   async promoteEligibleReplica(input) {
     assertNonEmpty(input.clusterId, "clusterId");
     assertNonEmpty(input.groupId, "groupId");
     const excludedNodeIds = new Set(input.excludeNodeIds ?? []);
-    for (let attempt = 0; attempt < 3; attempt++) {
+    for (let attempt = 0; attempt < MAX_PROMOTION_ATTEMPTS; attempt++) {
       const state = await this.getReplicationGroupState(input.clusterId, input.groupId);
       if (!state) {
         throw new NoSafePrimaryError(`No replication group '${input.groupId}' is registered`);
@@ -332,35 +440,12 @@ var EtcdClusterCoordinator = class {
     }
     throw new NoSafePrimaryError(`No safe primary is available for replication group '${input.groupId}'`);
   }
-  async close() {
-    const watcherCancels = [];
-    for (const watcher of this.watchers) {
-      watcherCancels.push(watcher.cancel());
-    }
-    this.watchers.clear();
-    await Promise.allSettled(watcherCancels);
-    const leaseRevokes = [];
-    for (const entry of this.leases.values()) {
-      leaseRevokes.push(revokeLeaseQuietly(entry.lease));
-    }
-    this.leases.clear();
-    await Promise.allSettled(leaseRevokes);
-    this.client.close();
-  }
-  async getLeaseFromKey(key) {
-    const value = await this.namespace.get(key).string();
-    return value ? parseLease(value) : null;
-  }
-  trackLease(lease, entry) {
-    const fullEntry = { ...entry, lease };
-    this.leases.set(entry.leaseId, fullEntry);
-    lease.on("lost", (err) => {
-      this.leases.delete(entry.leaseId);
-      this.onWatcherError?.(err instanceof Error ? err : new CoordinatorError(String(err)));
-    });
+  async getLiveNodeSession(clusterId, nodeId) {
+    const value = await this.namespace.get(nodeSessionKey(clusterId, nodeId)).string();
+    return value ? parseNodeSession(value) : null;
   }
   async updateGroupStateWithRetry(clusterId, groupId, mutate) {
-    for (let attempt = 0; attempt < 5; attempt++) {
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
       const state = await this.getReplicationGroupState(clusterId, groupId);
       if (!state) {
         return null;
@@ -387,257 +472,264 @@ var EtcdClusterCoordinator = class {
     return { updated: false, state: await this.getReplicationGroupState(previous.clusterId, previous.groupId) };
   }
 };
-function createEtcdCoordinator(options) {
-  return new EtcdClusterCoordinator(options);
-}
-function assertEtcdOptions(options) {
-  const hosts = Array.isArray(options.hosts) ? options.hosts : [options.hosts];
-  if (hosts.length === 0) {
-    throw new TypeError("hosts must contain at least one etcd endpoint");
+
+// src/replication/coordinator/etcd.ts
+var EtcdClusterCoordinator = class {
+  client;
+  namespace;
+  onWatcherError;
+  leases = /* @__PURE__ */ new Map();
+  grantedNodeSessionLeaseIds = /* @__PURE__ */ new Map();
+  watchers = /* @__PURE__ */ new Set();
+  groups;
+  constructor(options) {
+    assertEtcdOptions(options);
+    this.client = new Etcd3(toEtcdOptions(options));
+    this.namespace = this.client.namespace(normaliseKeyPrefix(options.keyPrefix));
+    this.onWatcherError = options.onWatcherError;
+    this.groups = new EtcdGroupStore(this.namespace, this.watchers, this.onWatcherError);
   }
-  for (const host of hosts) {
-    assertNonEmpty(host, "hosts entry");
-    if (!options.allowInsecure && !host.startsWith("https://")) {
-      throw new TypeError("production coordinator access requires https etcd endpoints");
+  async tryAcquireControllerLease(input) {
+    assertNonEmpty(input.clusterId, "clusterId");
+    assertNonEmpty(input.holderId, "holderId");
+    assertPositiveTtl(input.ttlMs);
+    const key = controllerLeaseKey(input.clusterId);
+    const lease = this.namespace.lease(ttlMsToSeconds(input.ttlMs));
+    const leaseId = await lease.grant();
+    const grantedAtMs = Date.now();
+    const value = serializeLease({
+      id: leaseId,
+      kind: "controller",
+      clusterId: input.clusterId,
+      holderId: input.holderId,
+      ttlMs: input.ttlMs,
+      grantedAtMs,
+      expiresAtMs: grantedAtMs + input.ttlMs,
+      metadata: cloneMetadata(input.metadata)
+    });
+    const result = await this.namespace.if(key, "Create", "==", 0).then(this.namespace.put(key).value(value).lease(leaseId)).commit();
+    if (!result.succeeded) {
+      await revokeLeaseQuietly(lease);
+      const current = await this.getLeaseFromKey(key);
+      return { acquired: false, lease: current };
     }
+    this.trackLease(lease, {
+      leaseId,
+      key,
+      ttlMs: input.ttlMs,
+      ttlSeconds: ttlMsToSeconds(input.ttlMs),
+      kind: "controller",
+      clusterId: input.clusterId,
+      holderId: input.holderId,
+      metadata: cloneMetadata(input.metadata)
+    });
+    const parsed = parseLease(value);
+    return { acquired: true, lease: parsed };
   }
-  assertNonEmpty(options.keyPrefix, "keyPrefix");
-  if (!options.allowInsecure && !options.credentials) {
-    throw new TypeError("production coordinator access requires TLS credentials");
-  }
-  const hasMtlsIdentity = Boolean(options.credentials?.privateKey && options.credentials.certChain);
-  const hasPasswordAuth = Boolean(options.auth?.username && options.auth.password);
-  if (!options.allowInsecure && !hasMtlsIdentity && !hasPasswordAuth) {
-    throw new TypeError("production coordinator access requires an authenticated Sirannon identity");
-  }
-}
-function toEtcdOptions(options) {
-  const defaultCallTimeoutMs = options.defaultCallTimeoutMs;
-  const defaultCallOptions = defaultCallTimeoutMs ? () => ({ deadline: Date.now() + defaultCallTimeoutMs }) : void 0;
-  return {
-    hosts: options.hosts,
-    credentials: options.credentials,
-    auth: options.auth,
-    grpcOptions: options.grpcOptions,
-    dialTimeout: options.dialTimeoutMs,
-    defaultCallOptions
-  };
-}
-function normaliseKeyPrefix(prefix) {
-  const trimmed = prefix.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (trimmed.length === 0) {
-    throw new TypeError("keyPrefix must not resolve to the etcd root");
-  }
-  return `${trimmed}/`;
-}
-function controllerLeaseKey(clusterId) {
-  return `clusters/${encodeKey(clusterId)}/controller`;
-}
-function nodeSessionKey(clusterId, nodeId) {
-  return `clusters/${encodeKey(clusterId)}/nodes/${encodeKey(nodeId)}`;
-}
-function replicationGroupKey(clusterId, groupId) {
-  return `clusters/${encodeKey(clusterId)}/groups/${encodeKey(groupId)}`;
-}
-function encodeKey(value) {
-  return encodeURIComponent(value);
-}
-function ttlMsToSeconds(ttlMs) {
-  return Math.max(1, Math.ceil(ttlMs / 1e3));
-}
-function buildReplicationGroupState(input) {
-  assertNonEmpty(input.clusterId, "clusterId");
-  assertNonEmpty(input.groupId, "groupId");
-  const votingDataBearingNodeIds = normaliseNodeIds(input.votingDataBearingNodeIds, "votingDataBearingNodeIds");
-  const inSyncNodeIds = normaliseNodeIds(input.inSyncNodeIds ?? [], "inSyncNodeIds");
-  const drainingNodeIds = normaliseNodeIds(input.drainingNodeIds ?? [], "drainingNodeIds");
-  const repairingNodeIds = normaliseNodeIds(input.repairingNodeIds ?? [], "repairingNodeIds");
-  const faultedNodeIds = normaliseNodeIds(input.faultedNodeIds ?? [], "faultedNodeIds");
-  assertNonNegativeTerm(input.primaryTerm ?? 0n);
-  assertNonNegativeSeq(input.durabilityPointSeq ?? 0n, "durabilityPointSeq");
-  assertPrimaryInGroup(input.currentPrimary ?? null, votingDataBearingNodeIds);
-  assertSubset(inSyncNodeIds, votingDataBearingNodeIds, "inSyncNodeIds");
-  assertSubset(drainingNodeIds, votingDataBearingNodeIds, "drainingNodeIds");
-  assertSubset(repairingNodeIds, votingDataBearingNodeIds, "repairingNodeIds");
-  assertSubset(faultedNodeIds, votingDataBearingNodeIds, "faultedNodeIds");
-  return {
-    clusterId: input.clusterId,
-    groupId: input.groupId,
-    votingDataBearingNodeIds,
-    currentPrimary: input.currentPrimary ? { ...input.currentPrimary } : null,
-    primaryTerm: input.primaryTerm ?? 0n,
-    durabilityPointSeq: input.durabilityPointSeq ?? 0n,
-    inSyncNodeIds,
-    drainingNodeIds,
-    repairingNodeIds,
-    faultedNodeIds,
-    compatibility: cloneCompatibility(input.compatibility),
-    updatedAtMs: Date.now()
-  };
-}
-function serializeLease(lease) {
-  return JSON.stringify(lease);
-}
-function parseLease(raw) {
-  const value = JSON.parse(raw);
-  return {
-    ...value,
-    metadata: cloneMetadata(value.metadata)
-  };
-}
-function parseNodeSession(raw) {
-  const value = JSON.parse(raw);
-  return {
-    ...value,
-    lease: parseLease(JSON.stringify(value.lease)),
-    groupIds: [...value.groupIds],
-    compatibility: cloneCompatibility(value.compatibility),
-    metadata: cloneMetadata(value.metadata)
-  };
-}
-function parseLeaseIdForEntry(kind, raw) {
-  try {
-    if (kind === "node-session") {
-      return parseNodeSession(raw).lease.id;
+  async renewLease(leaseId, ttlMs) {
+    assertNonEmpty(leaseId, "leaseId");
+    assertPositiveTtl(ttlMs);
+    const entry = this.leases.get(leaseId);
+    if (!entry) {
+      return false;
+    }
+    try {
+      await entry.lease.keepaliveOnce();
+    } catch {
+      this.leases.delete(leaseId);
+      return false;
     }
-    return parseLease(raw).id;
-  } catch {
-    return null;
+    const renewedAtMs = Date.now();
+    const leaseValue = {
+      id: leaseId,
+      kind: entry.kind,
+      clusterId: entry.clusterId,
+      holderId: entry.holderId,
+      ttlMs,
+      grantedAtMs: renewedAtMs,
+      expiresAtMs: renewedAtMs + ttlMs,
+      metadata: cloneMetadata(entry.metadata)
+    };
+    const value = entry.kind === "node-session" && entry.nodeSession ? JSON.stringify({ ...entry.nodeSession, lease: leaseValue }) : serializeLease(leaseValue);
+    let refreshed;
+    try {
+      const result = await this.namespace.if(entry.key, "Lease", "==", leaseId).then(this.namespace.put(entry.key).value(value).ignoreLease()).commit();
+      refreshed = result.succeeded === true;
+    } catch {
+      return true;
+    }
+    if (!refreshed) {
+      this.leases.delete(leaseId);
+      return false;
+    }
+    entry.ttlMs = ttlMs;
+    return true;
   }
-}
-function serializeGroupState(state) {
-  const serialized = {
-    ...state,
-    currentPrimary: state.currentPrimary ? { ...state.currentPrimary } : null,
-    votingDataBearingNodeIds: [...state.votingDataBearingNodeIds],
-    primaryTerm: state.primaryTerm.toString(),
-    durabilityPointSeq: state.durabilityPointSeq.toString(),
-    inSyncNodeIds: [...state.inSyncNodeIds],
-    drainingNodeIds: [...state.drainingNodeIds],
-    repairingNodeIds: [...state.repairingNodeIds],
-    faultedNodeIds: [...state.faultedNodeIds],
-    compatibility: cloneCompatibility(state.compatibility)
-  };
-  return JSON.stringify(serialized);
-}
-function parseGroupState(raw) {
-  const value = JSON.parse(raw);
-  return {
-    ...value,
-    currentPrimary: value.currentPrimary ? { ...value.currentPrimary } : null,
-    votingDataBearingNodeIds: [...value.votingDataBearingNodeIds],
-    primaryTerm: BigInt(value.primaryTerm),
-    durabilityPointSeq: value.durabilityPointSeq !== void 0 ? BigInt(value.durabilityPointSeq) : 0n,
-    inSyncNodeIds: [...value.inSyncNodeIds],
-    drainingNodeIds: [...value.drainingNodeIds],
-    repairingNodeIds: [...value.repairingNodeIds],
-    faultedNodeIds: [...value.faultedNodeIds ?? []],
-    compatibility: cloneCompatibility(value.compatibility)
-  };
-}
-function cloneReplicationGroupState(state) {
-  return {
-    ...state,
-    currentPrimary: state.currentPrimary ? { ...state.currentPrimary } : null,
-    votingDataBearingNodeIds: [...state.votingDataBearingNodeIds],
-    durabilityPointSeq: state.durabilityPointSeq,
-    inSyncNodeIds: [...state.inSyncNodeIds],
-    drainingNodeIds: [...state.drainingNodeIds],
-    repairingNodeIds: [...state.repairingNodeIds],
-    faultedNodeIds: [...state.faultedNodeIds],
-    compatibility: cloneCompatibility(state.compatibility)
-  };
-}
-function isEligiblePromotionSession(state, nodeId, session) {
-  if (!session) {
-    return false;
+  async releaseLease(leaseId) {
+    assertNonEmpty(leaseId, "leaseId");
+    const entry = this.leases.get(leaseId);
+    if (!entry) {
+      return false;
+    }
+    this.leases.delete(leaseId);
+    const currentValue = await this.namespace.get(entry.key).string();
+    const currentLeaseId = currentValue ? parseLeaseIdForEntry(entry.kind, currentValue) : null;
+    let released = false;
+    if (currentLeaseId === leaseId && currentValue) {
+      const result = await this.namespace.if(entry.key, "Value", "==", currentValue).then(this.namespace.delete().key(entry.key)).commit();
+      released = result.succeeded === true;
+    }
+    await revokeLeaseQuietly(entry.lease);
+    return released;
   }
-  return session.dataBearing && session.voting && state.inSyncNodeIds.includes(nodeId) && compatibilityAllowsPromotion(state.compatibility, session.compatibility) && !state.drainingNodeIds.includes(nodeId) && !state.repairingNodeIds.includes(nodeId) && !state.faultedNodeIds.includes(nodeId);
-}
-function normaliseNodeIds(nodeIds, name) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const nodeId of nodeIds) {
-    assertNonEmpty(nodeId, `${name} entry`);
-    if (seen.has(nodeId)) {
-      throw new RangeError(`${name} contains duplicate node id '${nodeId}'`);
+  async registerNodeSession(input) {
+    assertNonEmpty(input.clusterId, "clusterId");
+    assertNonEmpty(input.nodeId, "nodeId");
+    assertPositiveTtl(input.ttlMs);
+    const key = nodeSessionKey(input.clusterId, input.nodeId);
+    const existingRawSession = await this.namespace.get(key).string();
+    if (existingRawSession) {
+      const existingSession = parseNodeSession(existingRawSession);
+      const supersedesOwnSession = this.grantedNodeSessionLeaseIds.get(key) === existingSession.lease.id;
+      if (existingSession.lease.expiresAtMs > Date.now() && !supersedesOwnSession) {
+        throw new CoordinatorError(`Node session '${input.nodeId}' is already registered`);
+      }
     }
-    seen.add(nodeId);
-    result.push(nodeId);
+    const lease = this.namespace.lease(ttlMsToSeconds(input.ttlMs));
+    const leaseId = await lease.grant();
+    const grantedAtMs = Date.now();
+    const session = {
+      clusterId: input.clusterId,
+      nodeId: input.nodeId,
+      lease: {
+        id: leaseId,
+        kind: "node-session",
+        clusterId: input.clusterId,
+        holderId: input.nodeId,
+        ttlMs: input.ttlMs,
+        grantedAtMs,
+        expiresAtMs: grantedAtMs + input.ttlMs,
+        metadata: cloneMetadata(input.metadata)
+      },
+      endpoint: input.endpoint,
+      groupIds: [...input.groupIds ?? []],
+      dataBearing: input.dataBearing ?? true,
+      voting: input.voting ?? true,
+      compatibility: cloneCompatibility(input.compatibility),
+      metadata: cloneMetadata(input.metadata)
+    };
+    const rawSession = JSON.stringify(session);
+    const transaction = existingRawSession ? this.namespace.if(key, "Value", "==", existingRawSession) : this.namespace.if(key, "Create", "==", 0);
+    const result = await transaction.then(this.namespace.put(key).value(rawSession).lease(leaseId)).commit();
+    if (!result.succeeded) {
+      await revokeLeaseQuietly(lease);
+      throw new CoordinatorError(`Node session '${input.nodeId}' registration conflicted with a concurrent write`);
+    }
+    await this.discardSupersededLeases(key, leaseId);
+    this.grantedNodeSessionLeaseIds.set(key, leaseId);
+    this.trackLease(lease, {
+      leaseId,
+      key,
+      ttlMs: input.ttlMs,
+      ttlSeconds: ttlMsToSeconds(input.ttlMs),
+      kind: "node-session",
+      clusterId: input.clusterId,
+      holderId: input.nodeId,
+      metadata: cloneMetadata(input.metadata),
+      nodeSession: {
+        clusterId: session.clusterId,
+        nodeId: session.nodeId,
+        endpoint: session.endpoint,
+        groupIds: [...session.groupIds],
+        dataBearing: session.dataBearing,
+        voting: session.voting,
+        compatibility: cloneCompatibility(session.compatibility),
+        metadata: cloneMetadata(session.metadata)
+      }
+    });
+    return parseNodeSession(rawSession);
   }
-  return result;
-}
-function setMembership(values, nodeId, enabled) {
-  if (enabled === void 0) return values;
-  const next = values.filter((value) => value !== nodeId);
-  if (enabled) {
-    next.push(nodeId);
+  async getLiveNodeSession(clusterId, nodeId) {
+    assertNonEmpty(clusterId, "clusterId");
+    assertNonEmpty(nodeId, "nodeId");
+    const value = await this.namespace.get(nodeSessionKey(clusterId, nodeId)).string();
+    return value ? parseNodeSession(value) : null;
   }
-  return next;
-}
-function markDisplacedPrimaryForRepair(state, displacedPrimaryId, nextPrimaryId) {
-  if (!displacedPrimaryId || displacedPrimaryId === nextPrimaryId) return;
-  state.inSyncNodeIds = removeNodeId(state.inSyncNodeIds, displacedPrimaryId);
-  state.repairingNodeIds = setMembership(state.repairingNodeIds, displacedPrimaryId, true);
-}
-function removeNodeId(values, nodeId) {
-  return values.filter((value) => value !== nodeId);
-}
-function assertSubset(values, allowed, name) {
-  const allowedSet = new Set(allowed);
-  for (const value of values) {
-    if (!allowedSet.has(value)) {
-      throw new RangeError(`${name} contains node id '${value}' that is not configured for the replication group`);
+  async deregisterNodeSession(clusterId, nodeId) {
+    assertNonEmpty(clusterId, "clusterId");
+    assertNonEmpty(nodeId, "nodeId");
+    const key = nodeSessionKey(clusterId, nodeId);
+    for (const [leaseId, entry] of this.leases) {
+      if (entry.key === key) {
+        await this.releaseLease(leaseId);
+      }
     }
   }
-}
-function assertPrimaryInGroup(primary, votingDataBearingNodeIds) {
-  if (!primary) return;
-  assertNonEmpty(primary.nodeId, "primary.nodeId");
-  if (!votingDataBearingNodeIds.includes(primary.nodeId)) {
-    throw new RangeError(`Primary node '${primary.nodeId}' is not configured for the replication group`);
+  setReplicationGroupState(input) {
+    return this.groups.setReplicationGroupState(input);
   }
-}
-function assertNonNegativeTerm(term) {
-  if (term < 0n) {
-    throw new RangeError("primaryTerm must not be negative");
+  getReplicationGroupState(clusterId, groupId) {
+    return this.groups.getReplicationGroupState(clusterId, groupId);
   }
-}
-function assertNonNegativeSeq(seq, name) {
-  if (seq < 0n) {
-    throw new RangeError(`${name} must not be negative`);
+  watchReplicationGroup(clusterId, groupId, watcher) {
+    return this.groups.watchReplicationGroup(clusterId, groupId, watcher);
   }
-}
-function assertNoInSyncAdditions(previous, next) {
-  const previousSet = new Set(previous);
-  for (const nodeId of next) {
-    if (!previousSet.has(nodeId)) {
-      throw new RangeError(`Node '${nodeId}' cannot be added to the in-sync set without catch-up proof`);
+  compareAndAdvancePrimaryTerm(input) {
+    return this.groups.compareAndAdvancePrimaryTerm(input);
+  }
+  updateInSyncSet(input) {
+    return this.groups.updateInSyncSet(input);
+  }
+  admitNodeToInSyncSet(input) {
+    return this.groups.admitNodeToInSyncSet(input);
+  }
+  updateNodeMaintenance(input) {
+    return this.groups.updateNodeMaintenance(input);
+  }
+  promoteEligibleReplica(input) {
+    return this.groups.promoteEligibleReplica(input);
+  }
+  async close() {
+    const watcherCancels = [];
+    for (const watcher of this.watchers) {
+      watcherCancels.push(watcher.cancel());
+    }
+    this.watchers.clear();
+    await Promise.allSettled(watcherCancels);
+    const leaseRevokes = [];
+    for (const entry of this.leases.values()) {
+      leaseRevokes.push(revokeLeaseQuietly(entry.lease));
     }
+    this.leases.clear();
+    this.grantedNodeSessionLeaseIds.clear();
+    await Promise.allSettled(leaseRevokes);
+    this.client.close();
   }
-}
-function arraysEqual(left, right) {
-  if (left.length !== right.length) return false;
-  for (let i = 0; i < left.length; i++) {
-    if (left[i] !== right[i]) return false;
+  async discardSupersededLeases(key, keepLeaseId) {
+    const superseded = [];
+    for (const [leaseId, entry] of this.leases) {
+      if (entry.key === key && leaseId !== keepLeaseId) {
+        this.leases.delete(leaseId);
+        superseded.push(entry);
+      }
+    }
+    await Promise.allSettled(superseded.map((entry) => revokeLeaseQuietly(entry.lease)));
   }
-  return true;
-}
-function cloneCompatibility(compatibility) {
-  return compatibility ? { ...compatibility } : void 0;
-}
-function cloneMetadata(metadata) {
-  return metadata ? { ...metadata } : void 0;
-}
-function assertPositiveTtl(ttlMs) {
-  if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0) {
-    throw new RangeError("ttlMs must be a positive safe integer");
+  async getLeaseFromKey(key) {
+    const value = await this.namespace.get(key).string();
+    return value ? parseLease(value) : null;
   }
-}
-function assertNonEmpty(value, name) {
-  if (value.length === 0) {
-    throw new TypeError(`${name} must not be empty`);
+  trackLease(lease, entry) {
+    const fullEntry = { ...entry, lease };
+    this.leases.set(entry.leaseId, fullEntry);
+    lease.on("lost", (err) => {
+      this.leases.delete(entry.leaseId);
+      this.onWatcherError?.(err instanceof Error ? err : new CoordinatorError(String(err)));
+    });
   }
+};
+function createEtcdCoordinator(options) {
+  return new EtcdClusterCoordinator(options);
 }
 async function revokeLeaseQuietly(lease) {
   try {