@delali/sirannon-db 0.4.1-next.88 → 0.4.1-next.89

package/dist/backup/index.mjs

@@ -1,6 +1,6 @@
-export { assembleFromDestination, restoreBackup } from '../chunk-M3POIJ4C.mjs';
-export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-GCOJFQOL.mjs';
-import '../chunk-O3FX3SD4.mjs';
+export { assembleFromDestination, restoreBackup } from '../chunk-RBA6WMXU.mjs';
+export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-EOESJH5I.mjs';
+import '../chunk-V4NPLS4E.mjs';
 export { verifyBackupRecord } from '../chunk-DX4WGJL7.mjs';
 import '../chunk-QGVRRKB2.mjs';
 import '../chunk-BUWJH3D3.mjs';

package/dist/{chunk-MTOQ6QIS.mjs → chunk-2EYLKZZY.mjs}

@@ -1,5 +1,5 @@
 import { ReplicationError, BatchValidationError } from './chunk-BLMRNSUG.mjs';
-import { CHANGES_TABLE, META_TABLE, MIGRATIONS_TABLE, REPLACED_ROWS_TABLE, APPLIED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-ZAUHAJ4G.mjs';
+import { CHANGES_TABLE, META_TABLE, MIGRATIONS_TABLE, REPLACED_ROWS_TABLE, ROLLED_BACK_CHANGES_TABLE, APPLIED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-ZD5FP3IW.mjs';
 import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/sync/hlc.ts
@@ -434,6 +434,77 @@ async function deleteAllReplacedRows(conn) {
   await conn.exec(`DELETE FROM "${REPLACED_ROWS_TABLE}"`);
 }
 
+// src/core/system-catalog/rolled-back-changes-table.ts
+var INSERT_ROLLED_BACK_COLUMNS = "seq, rolled_back_at, rolled_back_in_term, table_name, operation, row_id, old_data, new_data, node_id, tx_id, hlc, compared_with_primary";
+var KEEP_STRONGER_COMPARISON = "ON CONFLICT(seq) DO UPDATE SET compared_with_primary = MAX(compared_with_primary, excluded.compared_with_primary)";
+function originPlaceholders(originCount) {
+  return Array.from({ length: originCount }, () => "?").join(", ");
+}
+async function ensureRolledBackChangesTable(conn) {
+  await conn.exec(
+    `CREATE TABLE IF NOT EXISTS "${ROLLED_BACK_CHANGES_TABLE}" (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      seq INTEGER NOT NULL UNIQUE,
+      rolled_back_at REAL NOT NULL,
+      rolled_back_in_term TEXT NOT NULL,
+      table_name TEXT NOT NULL,
+      operation TEXT NOT NULL,
+      row_id TEXT NOT NULL,
+      old_data TEXT,
+      new_data TEXT,
+      node_id TEXT NOT NULL,
+      tx_id TEXT NOT NULL,
+      hlc TEXT NOT NULL,
+      compared_with_primary INTEGER NOT NULL
+    )`
+  );
+}
+async function insertRolledBackChangesAfterHlc(conn, changesTable, origins, hlc, term, nowSeconds) {
+  if (origins.length === 0) return;
+  const stmt = await conn.prepare(
+    `INSERT INTO "${ROLLED_BACK_CHANGES_TABLE}" (${INSERT_ROLLED_BACK_COLUMNS})
+     SELECT seq, ?, ?, table_name, operation, row_id, old_data, new_data, node_id, tx_id, hlc, 1 FROM "${changesTable}"
+     WHERE hlc != '' AND hlc > ? AND node_id IN (${originPlaceholders(origins.length)})
+     ORDER BY seq
+     ${KEEP_STRONGER_COMPARISON}`
+  );
+  await stmt.run(nowSeconds, term.toString(), hlc ?? "", ...origins);
+}
+async function insertRolledBackChangesNotFromPrimary(conn, changesTable, origins, primaryNodeId, term, nowSeconds) {
+  if (origins.length === 0) return;
+  const stmt = await conn.prepare(
+    `INSERT INTO "${ROLLED_BACK_CHANGES_TABLE}" (${INSERT_ROLLED_BACK_COLUMNS})
+     SELECT seq, ?, ?, table_name, operation, row_id, old_data, new_data, node_id, tx_id, hlc, 0 FROM "${changesTable}"
+     WHERE hlc != '' AND node_id IN (${originPlaceholders(origins.length)}) AND node_id != ?
+     ORDER BY seq
+     ${KEEP_STRONGER_COMPARISON}`
+  );
+  await stmt.run(nowSeconds, term.toString(), ...origins, primaryNodeId);
+}
+async function selectRolledBackChanges(conn) {
+  const stmt = await conn.prepare(
+    `SELECT ${INSERT_ROLLED_BACK_COLUMNS} FROM "${ROLLED_BACK_CHANGES_TABLE}" ORDER BY id`
+  );
+  const rows = await stmt.all();
+  return rows.map((row) => ({
+    seq: BigInt(row.seq),
+    rolledBackAt: Number(row.rolled_back_at),
+    rolledBackInTerm: BigInt(row.rolled_back_in_term),
+    tableName: row.table_name,
+    operation: row.operation,
+    rowId: row.row_id,
+    oldData: row.old_data,
+    newData: row.new_data,
+    nodeId: row.node_id,
+    txId: row.tx_id,
+    hlc: row.hlc,
+    comparedWithPrimary: Number(row.compared_with_primary) === 1
+  }));
+}
+async function deleteRolledBackChanges(conn) {
+  await conn.exec(`DELETE FROM "${ROLLED_BACK_CHANGES_TABLE}"`);
+}
+
 // src/core/system-catalog/applied-changes-table.ts
 async function ensureAppliedChangesTable(conn) {
   await conn.exec(`
@@ -492,12 +563,12 @@ async function selectAppliedSourceSeqsInRange(conn, sourceNodeId, fromSeq, toSeq
 }
 
 // src/core/system-catalog/changes-history.ts
-function originPlaceholders(originCount) {
+function originPlaceholders2(originCount) {
   return Array.from({ length: originCount }, () => "?").join(", ");
 }
 function selectOutboundHistoryChangesSql(tableName, originCount) {
   return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}"
-          WHERE seq > ? AND hlc != '' AND node_id IN (${originPlaceholders(originCount)})
+          WHERE seq > ? AND hlc != '' AND node_id IN (${originPlaceholders2(originCount)})
           ORDER BY seq ASC LIMIT ?`;
 }
 async function selectNewestHistoryChange(conn, tableName, origins, bounds = {}) {
@@ -506,7 +577,7 @@ async function selectNewestHistoryChange(conn, tableName, origins, bounds = {})
   const hlcFilter = bounds.beforeHlc === void 0 ? "" : "AND hlc < ?";
   const stmt = await conn.prepare(
     `SELECT seq, hlc, tx_id FROM "${tableName}"
-     WHERE hlc != '' AND node_id IN (${originPlaceholders(origins.length)}) ${seqFilter} ${hlcFilter}
+     WHERE hlc != '' AND node_id IN (${originPlaceholders2(origins.length)}) ${seqFilter} ${hlcFilter}
      ORDER BY hlc DESC, seq DESC LIMIT 1`
   );
   const params = [...origins];
@@ -524,7 +595,7 @@ async function selectMaxHistoryChangeSeq(conn, tableName, origins) {
   if (origins.length === 0) return 0n;
   const stmt = await conn.prepare(
     `SELECT COALESCE(MAX(seq), 0) AS seq FROM "${tableName}"
-     WHERE hlc != '' AND node_id IN (${originPlaceholders(origins.length)})`
+     WHERE hlc != '' AND node_id IN (${originPlaceholders2(origins.length)})`
   );
   const row = await stmt.get(...origins);
   return seqFromColumn(row?.seq);
@@ -541,7 +612,7 @@ async function selectHistoryChangesAfterHlc(conn, tableName, origins, hlc) {
   if (origins.length === 0) return [];
   const stmt = await conn.prepare(
     `SELECT seq, table_name, operation, row_id, old_data, new_data FROM "${tableName}"
-     WHERE hlc > ? AND node_id IN (${originPlaceholders(origins.length)})
+     WHERE hlc > ? AND node_id IN (${originPlaceholders2(origins.length)})
      ORDER BY seq DESC`
   );
   return await stmt.all(hlc, ...origins);
@@ -549,7 +620,7 @@ async function selectHistoryChangesAfterHlc(conn, tableName, origins, hlc) {
 async function deleteHistoryChangesAfterHlc(conn, tableName, origins, hlc) {
   if (origins.length === 0) return;
   const stmt = await conn.prepare(
-    `DELETE FROM "${tableName}" WHERE hlc > ? AND node_id IN (${originPlaceholders(origins.length)})`
+    `DELETE FROM "${tableName}" WHERE hlc > ? AND node_id IN (${originPlaceholders2(origins.length)})`
   );
   await stmt.run(hlc, ...origins);
 }
@@ -880,6 +951,7 @@ async function ensureReplicationStateTables(conn) {
   await ensurePeerStateTable(conn);
   await ensureBatchApplyTables(conn);
   await ensureSyncStateTable(conn);
+  await ensureRolledBackChangesTable(conn);
 }
 
 // src/core/system-catalog/staged-changes-table.ts
@@ -1140,4 +1212,4 @@ function attributeChangeSeqs(batch) {
   });
 }
 
-export { HLC, IDENTIFIER_RE, MAX_CHANGE_SEQ, PkResolver, SEQ_STRING_RE, TABLE_XINFO_HIDDEN, assertSafeIdentifier, attributeChangeSeqs, canonicaliseForChecksum, deleteAllReplacedRows, deleteAllStagedChanges, deleteAppliedChangesAfterSeq, deleteChangesBeforeUpToSeqSql, deleteColumnVersions, deleteColumnVersionsAfterHlc, deleteExpiredDeviceCursors, deleteHistoryChangesAfterHlc, deleteMetaValue, deletePeerState, deletePeerStates, deletePrimaryTermStart, deleteReplacedRowsOfTable, deleteStagedChangesUpToSeq, deleteStagedPushChanges, deleteStampedChangesUpToSeq, deleteSyncTableStates, ensureBatchApplyTables, ensureChangesTable, ensureDeviceCursorsTable, ensureMetaTable, ensureMigrationsTable, ensureReplacedRowsTable, ensureReplicationStateTables, ensureStagedChangesTable, ensureStagedPushChangesTable, extractDroppedTable, highestMigrationVersion, indexColumns, insertAppliedChangesFromStagedPush, insertDdlChange, insertMetaValueIfAbsent, prepareDeleteMigration, prepareDeleteRowColumnVersions, prepareInsertAppliedChange, prepareInsertMigration, prepareInsertStagedPushChange, prepareUpdateMigrationChecksum, prepareUpsertColumnVersion, prepareUpsertNewerColumnVersion, primaryKeyColumns, referencedTables, replaceMigrationHistory, selectAnchoredTerm, selectAppliedMigrations, selectAppliedMigrationsNewestFirst, selectAppliedSourceSeqsInRange, selectChangesAfterSeqSql, selectCompletedSyncTableNames, selectCountOutboundChanges, selectCountTableRows, selectDeviceCursorExists, selectFirstStagedTransactionEnd, selectHistoryBase, selectHistoryChangesAfterHlc, selectHistoryTransaction, selectIndexSql, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxAssignedChangeSeq, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxHistoryChangeSeq, selectMaxNodeChangeSeq, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinDeviceCursorBoundary, selectMinPeerAckedSeq, selectNewestHistoryChange, selectNodeChangesAfterSeqSql, selectOrdinaryTableName, selectOutboundChangesSql, selectOutboundHistoryChangesSql, selectPeerAckedSeq, selectPrimaryTermStart, selectQuarantined, selectStagedChangesInRange, selectStagedPushChangesAfter, selectStagedPushSeqsInRange, selectStagedPushTail, selectSyncMetaRow, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectTriggerSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnsWithGenerated, tableIndexList, tableInfoRows, tablePkColumns, updateChangeStampsAboveMetaSeqSql, updateChangeStampsAfterSeqSql, updateDeviceCursor, upsertAnchoredTerm, upsertDeviceCursor, upsertHistoryBase, upsertMetaMaxChangeSeqSql, upsertMetaValue, upsertMetaValueAndMaxChangeSeqSql, upsertPeerAckedSeq, upsertPrimaryTermStart, upsertQuarantined, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };
+export { HLC, IDENTIFIER_RE, MAX_CHANGE_SEQ, PkResolver, SEQ_STRING_RE, TABLE_XINFO_HIDDEN, assertSafeIdentifier, attributeChangeSeqs, canonicaliseForChecksum, deleteAllReplacedRows, deleteAllStagedChanges, deleteAppliedChangesAfterSeq, deleteChangesBeforeUpToSeqSql, deleteColumnVersions, deleteColumnVersionsAfterHlc, deleteExpiredDeviceCursors, deleteHistoryChangesAfterHlc, deleteMetaValue, deletePeerState, deletePeerStates, deletePrimaryTermStart, deleteReplacedRowsOfTable, deleteRolledBackChanges, deleteStagedChangesUpToSeq, deleteStagedPushChanges, deleteStampedChangesUpToSeq, deleteSyncTableStates, ensureBatchApplyTables, ensureChangesTable, ensureDeviceCursorsTable, ensureMetaTable, ensureMigrationsTable, ensureReplacedRowsTable, ensureReplicationStateTables, ensureRolledBackChangesTable, ensureStagedChangesTable, ensureStagedPushChangesTable, extractDroppedTable, highestMigrationVersion, indexColumns, insertAppliedChangesFromStagedPush, insertDdlChange, insertMetaValueIfAbsent, insertRolledBackChangesAfterHlc, insertRolledBackChangesNotFromPrimary, prepareDeleteMigration, prepareDeleteRowColumnVersions, prepareInsertAppliedChange, prepareInsertMigration, prepareInsertStagedPushChange, prepareUpdateMigrationChecksum, prepareUpsertColumnVersion, prepareUpsertNewerColumnVersion, primaryKeyColumns, referencedTables, replaceMigrationHistory, selectAnchoredTerm, selectAppliedMigrations, selectAppliedMigrationsNewestFirst, selectAppliedSourceSeqsInRange, selectChangesAfterSeqSql, selectCompletedSyncTableNames, selectCountOutboundChanges, selectCountTableRows, selectDeviceCursorExists, selectFirstStagedTransactionEnd, selectHistoryBase, selectHistoryChangesAfterHlc, selectHistoryTransaction, selectIndexSql, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxAssignedChangeSeq, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxHistoryChangeSeq, selectMaxNodeChangeSeq, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinDeviceCursorBoundary, selectMinPeerAckedSeq, selectNewestHistoryChange, selectNodeChangesAfterSeqSql, selectOrdinaryTableName, selectOutboundChangesSql, selectOutboundHistoryChangesSql, selectPeerAckedSeq, selectPrimaryTermStart, selectQuarantined, selectRolledBackChanges, selectStagedChangesInRange, selectStagedPushChangesAfter, selectStagedPushSeqsInRange, selectStagedPushTail, selectSyncMetaRow, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectTriggerSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnsWithGenerated, tableIndexList, tableInfoRows, tablePkColumns, updateChangeStampsAboveMetaSeqSql, updateChangeStampsAfterSeqSql, updateDeviceCursor, upsertAnchoredTerm, upsertDeviceCursor, upsertHistoryBase, upsertMetaMaxChangeSeqSql, upsertMetaValue, upsertMetaValueAndMaxChangeSeqSql, upsertPeerAckedSeq, upsertPrimaryTermStart, upsertQuarantined, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };

package/dist/{chunk-PJRCMG7L.mjs → chunk-4GRS2L3L.mjs}

@@ -22,6 +22,30 @@ function parseMajorVersion(version) {
 
 // src/replication/coordinator/group-rules.ts
 var MIN_AUTOMATIC_FAILOVER_VOTERS = 3;
+var MAX_GROUP_VOTERS = 7;
+var FIRST_FEATURE_LEVEL = 1;
+var IN_SYNC_ACKNOWLEDGEMENT_FEATURE_LEVEL = 2;
+function majorityOf(voterCount) {
+  return Math.floor(voterCount / 2) + 1;
+}
+function recordInSyncMajority(state) {
+  const voters = state.votingDataBearingNodeIds;
+  const inSyncVoters = state.inSyncNodeIds.filter((nodeId) => voters.includes(nodeId)).length;
+  if (state.inSyncMajorityTerm >= state.primaryTerm || inSyncVoters < majorityOf(voters.length)) return state;
+  return { ...state, inSyncMajorityTerm: state.primaryTerm };
+}
+function assertVoterCap(voterCount, groupId) {
+  if (voterCount > MAX_GROUP_VOTERS) {
+    throw new RangeError(
+      `Replication group '${groupId}' would hold ${voterCount} voters and pending voters, more than the limit of ${MAX_GROUP_VOTERS}`
+    );
+  }
+}
+function assertFeatureLevel(featureLevel) {
+  if (!Number.isSafeInteger(featureLevel) || featureLevel < FIRST_FEATURE_LEVEL) {
+    throw new RangeError(`featureLevel must be a safe integer of at least ${FIRST_FEATURE_LEVEL}`);
+  }
+}
 function assertNonEmpty(value, name) {
   if (value.length === 0) {
     throw new TypeError(`${name} must not be empty`);
@@ -99,10 +123,9 @@ function arraysEqual(left, right) {
 function sameNodeIdSet(left, right) {
   return left.length === right.length && left.every((nodeId) => right.includes(nodeId));
 }
-function markDisplacedPrimaryForRepair(state, displacedPrimaryId, nextPrimaryId) {
+function removeDisplacedPrimaryFromInSyncSet(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;
@@ -125,6 +148,11 @@ function nextInSyncSetState(state, input, nowMs) {
   assertSubset(inSyncNodeIds, state.votingDataBearingNodeIds, "inSyncNodeIds");
   assertNoInSyncAdditions(state.inSyncNodeIds, inSyncNodeIds);
   const durabilityPointSeq = input.durabilityPointSeq !== void 0 && input.durabilityPointSeq > state.durabilityPointSeq ? input.durabilityPointSeq : state.durabilityPointSeq;
+  const primaryRemoval = input.expectedPrimaryNodeId !== void 0 && inSyncNodeIds.length < state.inSyncNodeIds.length;
+  if (primaryRemoval && inSyncNodeIds.length < majorityOf(state.votingDataBearingNodeIds.length)) {
+    if (durabilityPointSeq === state.durabilityPointSeq) return state;
+    return { ...state, durabilityPointSeq, updatedAtMs: nowMs };
+  }
   if (arraysEqual(inSyncNodeIds, state.inSyncNodeIds) && durabilityPointSeq === state.durabilityPointSeq) {
     return state;
   }
@@ -133,9 +161,15 @@ function nextInSyncSetState(state, input, nowMs) {
 function nextAdmittedInSyncState(state, input, nowMs) {
   assertNodeInGroup(state, input.nodeId);
   const pendingVoter = state.pendingVoterNodeIds.includes(input.nodeId);
-  if (state.currentPrimary?.nodeId !== input.sourceNodeId || input.expectedPrimaryTerm !== void 0 && state.primaryTerm !== input.expectedPrimaryTerm || state.drainingNodeIds.includes(input.nodeId) || state.faultedNodeIds.includes(input.nodeId) || (pendingVoter || state.repairingNodeIds.includes(input.nodeId)) && input.rejoinSyncCompleted !== true || input.appliedSeq < state.durabilityPointSeq) {
+  const repairing = state.repairingNodeIds.includes(input.nodeId);
+  const pendingVoterNeedsCopy = pendingVoter && state.featureLevel < IN_SYNC_ACKNOWLEDGEMENT_FEATURE_LEVEL;
+  if (state.currentPrimary?.nodeId !== input.sourceNodeId || input.expectedPrimaryTerm !== void 0 && state.primaryTerm !== input.expectedPrimaryTerm || state.drainingNodeIds.includes(input.nodeId) || state.faultedNodeIds.includes(input.nodeId) || (pendingVoterNeedsCopy || repairing) && input.rejoinSyncCompleted !== true || input.appliedSeq < state.durabilityPointSeq) {
     return state;
   }
+  if (input.clearRepairingOnly === true) {
+    if (!repairing) return state;
+    return { ...state, repairingNodeIds: removeNodeId(state.repairingNodeIds, input.nodeId), updatedAtMs: nowMs };
+  }
   const inSyncNodeIds = state.inSyncNodeIds.includes(input.nodeId) ? state.inSyncNodeIds : [...state.inSyncNodeIds, input.nodeId];
   const repairingNodeIds = removeNodeId(state.repairingNodeIds, input.nodeId);
   if (pendingVoter) {
@@ -187,6 +221,9 @@ function buildReplicationGroupState(input, nowMs = Date.now()) {
   const pendingVoterNodeIds = normaliseNodeIds(input.pendingVoterNodeIds ?? [], "pendingVoterNodeIds");
   assertNonNegativeTerm(input.primaryTerm ?? 0n);
   assertNonNegativeSeq(input.durabilityPointSeq ?? 0n, "durabilityPointSeq");
+  const featureLevel = input.featureLevel ?? FIRST_FEATURE_LEVEL;
+  assertFeatureLevel(featureLevel);
+  assertVoterCap(votingDataBearingNodeIds.length + pendingVoterNodeIds.length, input.groupId);
   assertPrimaryInGroup(input.currentPrimary ?? null, votingDataBearingNodeIds);
   for (const nodeId of pendingVoterNodeIds) {
     if (votingDataBearingNodeIds.includes(nodeId)) {
@@ -198,7 +235,7 @@ function buildReplicationGroupState(input, nowMs = Date.now()) {
   assertSubset(drainingNodeIds, memberNodeIds, "drainingNodeIds");
   assertSubset(repairingNodeIds, memberNodeIds, "repairingNodeIds");
   assertSubset(faultedNodeIds, memberNodeIds, "faultedNodeIds");
-  return {
+  return recordInSyncMajority({
     clusterId: input.clusterId,
     groupId: input.groupId,
     votingDataBearingNodeIds,
@@ -211,8 +248,10 @@ function buildReplicationGroupState(input, nowMs = Date.now()) {
     faultedNodeIds,
     pendingVoterNodeIds,
     compatibility: cloneCompatibility(input.compatibility),
+    featureLevel,
+    inSyncMajorityTerm: input.inSyncMajorityTerm ?? 0n,
     updatedAtMs: nowMs
-  };
+  });
 }
 function cloneReplicationGroupState(state) {
   return {
@@ -229,4 +268,4 @@ function cloneReplicationGroupState(state) {
   };
 }
 
-export { MIN_AUTOMATIC_FAILOVER_VOTERS, arraysEqual, assertNonEmpty, assertNonNegativeSeq, assertNonNegativeTerm, assertPositiveTtl, assertPrimaryInGroup, buildReplicationGroupState, cloneCompatibility, cloneMetadata, cloneReplicationGroupState, compatibilityAllowsPromotion, groupMemberIds, isEligiblePromotionSession, isGroupMember, markDisplacedPrimaryForRepair, nextAdmittedInSyncState, nextInSyncSetState, nextMaintenanceState, normaliseNodeIds, removeNodeId, sameNodeIdSet, setMembership };
+export { FIRST_FEATURE_LEVEL, IN_SYNC_ACKNOWLEDGEMENT_FEATURE_LEVEL, MIN_AUTOMATIC_FAILOVER_VOTERS, assertFeatureLevel, assertNonEmpty, assertNonNegativeSeq, assertNonNegativeTerm, assertPositiveTtl, assertPrimaryInGroup, assertVoterCap, buildReplicationGroupState, cloneCompatibility, cloneMetadata, cloneReplicationGroupState, compatibilityAllowsPromotion, groupMemberIds, isEligiblePromotionSession, isGroupMember, majorityOf, nextAdmittedInSyncState, nextInSyncSetState, nextMaintenanceState, normaliseNodeIds, recordInSyncMajority, removeDisplacedPrimaryFromInSyncSet, removeNodeId, sameNodeIdSet, setMembership };

package/dist/{chunk-ZWW53O5P.mjs → chunk-C3OVUSZP.mjs}

@@ -1,4 +1,4 @@
-import { encodeWireRowsInPlace, assertSqlAllowed } from './chunk-ZAUHAJ4G.mjs';
+import { encodeWireRowsInPlace, assertSqlAllowed } from './chunk-ZD5FP3IW.mjs';
 import { withRowCounts, rowCountsOf, allMetered, addRowCounts } from './chunk-E2GRX4ZD.mjs';
 import { SirannonError, QueryError, TransactionError } from './chunk-KINDFBQP.mjs';
 

package/dist/{chunk-ULUZUBON.mjs → chunk-DQ5EB7CS.mjs}

@@ -1,4 +1,4 @@
-import { execute, commitFailure, asQueryError } from './chunk-ZWW53O5P.mjs';
+import { execute, commitFailure, asQueryError } from './chunk-C3OVUSZP.mjs';
 import { rowCountsOf } from './chunk-E2GRX4ZD.mjs';
 
 // src/core/group-executor.ts

package/dist/{chunk-GCOJFQOL.mjs → chunk-EOESJH5I.mjs}

@@ -1,4 +1,4 @@
-import { pipe, instance, check, union, object, optional, string, safeParse } from './chunk-O3FX3SD4.mjs';
+import { pipe, instance, check, union, object, optional, string, safeParse } from './chunk-V4NPLS4E.mjs';
 import { EncryptionError } from './chunk-5O4J6LQQ.mjs';
 import { SirannonError } from './chunk-KINDFBQP.mjs';
 

package/dist/{chunk-GBVB6WSC.mjs → chunk-IZ3CM4MI.mjs}

@@ -1,6 +1,6 @@
-import { IDENTIFIER_RE, selectCountTableRows, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-MTOQ6QIS.mjs';
+import { IDENTIFIER_RE, selectCountTableRows, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-2EYLKZZY.mjs';
 import { ReplicationError } from './chunk-BLMRNSUG.mjs';
-import { INTERNAL_TABLE_PREFIX } from './chunk-ZAUHAJ4G.mjs';
+import { INTERNAL_TABLE_PREFIX } from './chunk-ZD5FP3IW.mjs';
 import { createHash } from 'crypto';
 
 var DumpOps = class {

package/dist/{chunk-RWPKDNT3.mjs → chunk-K3Z4TEP2.mjs}

@@ -1,7 +1,7 @@
 import { readSelectItems, findClauses } from './chunk-D3YF2G7X.mjs';
 import { operationRegistryDigest } from './chunk-KB4OLJAD.mjs';
 import { tokenizeSql } from './chunk-SEL4A4WT.mjs';
-import { custom, array, string, object, nullable, optional, literal, safeParse, getDotPath } from './chunk-O3FX3SD4.mjs';
+import { custom, array, string, object, nullable, optional, literal, safeParse, getDotPath } from './chunk-V4NPLS4E.mjs';
 import { readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { pathToFileURL } from 'url';

package/dist/{chunk-VKCUSREW.mjs → chunk-PR2APVRF.mjs}

@@ -1,9 +1,9 @@
-import { withoutRowCounts, runWriterTransaction, queryMetered, execute, executeBatch } from './chunk-ZWW53O5P.mjs';
-import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, attributeChangeSeqs, validateDdlSafety, insertDdlChange, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundHistoryChangesSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareUpsertNewerColumnVersion, canonicaliseForChecksum, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion, selectTableExists, selectAppliedSourceSeqsInRange, selectStagedPushTail, selectStagedPushSeqsInRange, deleteStagedPushChanges, prepareInsertStagedPushChange, selectStagedPushChangesAfter, insertAppliedChangesFromStagedPush, prepareInsertAppliedChange } from './chunk-MTOQ6QIS.mjs';
+import { withoutRowCounts, runWriterTransaction, queryMetered, execute, executeBatch } from './chunk-C3OVUSZP.mjs';
+import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, attributeChangeSeqs, validateDdlSafety, insertDdlChange, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundHistoryChangesSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareUpsertNewerColumnVersion, canonicaliseForChecksum, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion, selectTableExists, selectAppliedSourceSeqsInRange, selectStagedPushTail, selectStagedPushSeqsInRange, deleteStagedPushChanges, prepareInsertStagedPushChange, selectStagedPushChangesAfter, insertAppliedChangesFromStagedPush, prepareInsertAppliedChange } from './chunk-2EYLKZZY.mjs';
 import { BatchValidationError, ConflictError, ReplicationError } from './chunk-BLMRNSUG.mjs';
-import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, encodeTaggedValues } from './chunk-ZAUHAJ4G.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, encodeTaggedValues } from './chunk-ZD5FP3IW.mjs';
 import { sha256Hex } from './chunk-GVCNMPOS.mjs';
-import { record, string, unknown, object, optional, nullable, picklist, safeParse, summarize } from './chunk-O3FX3SD4.mjs';
+import { record, string, unknown, object, optional, nullable, picklist, safeParse, summarize } from './chunk-V4NPLS4E.mjs';
 import { lateRowCountsOf } from './chunk-K43WJORM.mjs';
 import { rowCountsOf, totalRowCounts, addRowCounts } from './chunk-E2GRX4ZD.mjs';
 import { invokeCallerCallback } from './chunk-HO2XTXVX.mjs';

package/dist/{chunk-M3POIJ4C.mjs → chunk-RBA6WMXU.mjs}

@@ -1,4 +1,4 @@
-import { planBackupRestore, EncryptionKeyring } from './chunk-GCOJFQOL.mjs';
+import { planBackupRestore, EncryptionKeyring } from './chunk-EOESJH5I.mjs';
 import { listStoredFilePieces, fetchStoredFile, checkpointLog } from './chunk-QGVRRKB2.mjs';
 import { reportQuietly, LOG_HEADER_BYTES, LOG_FRAME_HEADER_BYTES, readLogHeader, foldLogChecksum, MAGIC_WITH_LITTLE_ENDIAN_CONTENT, LOG_FORMAT_VERSION } from './chunk-BUWJH3D3.mjs';
 import { readBackupChains, DEFAULT_CHAIN_NAME } from './chunk-6CABU54O.mjs';

package/dist/{chunk-2ZQOZFX7.mjs → chunk-S36XLMIW.mjs}

@@ -1,5 +1,5 @@
-import { selectOrdinaryTableName, deleteReplacedRowsOfTable, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteAllReplacedRows, selectTableExists, ensureChangesTable, ensureReplacedRowsTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectTriggerSql, selectChangesAfterSeqSql, selectTablesChangesInRangeSql, tableInfoRows, primaryKeyColumns, tableColumnsWithGenerated, tableIndexList, indexColumns, selectTableSql, TABLE_XINFO_HIDDEN, deleteExpiredDeviceCursors, selectMinDeviceCursorBoundary, SEQ_STRING_RE, selectIndexSql } from './chunk-MTOQ6QIS.mjs';
-import { CDC_TRIGGER_PREFIX, CHANGES_TABLE, isReservedIdentifier, META_TABLE, encodeTaggedValues, REPLACED_ROWS_TABLE, changedAtToEventTimestamp, decodeTaggedValues, DEVICE_CURSORS_TABLE, SAFE_INT_BOUND_TEXT } from './chunk-ZAUHAJ4G.mjs';
+import { selectOrdinaryTableName, deleteReplacedRowsOfTable, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteAllReplacedRows, selectTableExists, ensureChangesTable, ensureReplacedRowsTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectTriggerSql, selectChangesAfterSeqSql, selectTablesChangesInRangeSql, tableInfoRows, primaryKeyColumns, tableColumnsWithGenerated, tableIndexList, indexColumns, selectTableSql, TABLE_XINFO_HIDDEN, deleteExpiredDeviceCursors, selectMinDeviceCursorBoundary, SEQ_STRING_RE, selectIndexSql } from './chunk-2EYLKZZY.mjs';
+import { CDC_TRIGGER_PREFIX, CHANGES_TABLE, isReservedIdentifier, META_TABLE, encodeTaggedValues, REPLACED_ROWS_TABLE, changedAtToEventTimestamp, decodeTaggedValues, DEVICE_CURSORS_TABLE, SAFE_INT_BOUND_TEXT } from './chunk-ZD5FP3IW.mjs';
 import { tokenizeSql, isKeyword } from './chunk-SEL4A4WT.mjs';
 import { randomHex } from './chunk-BGJ5JVYL.mjs';
 import { invokeCallerCallback, reportCallerFailure, toError } from './chunk-HO2XTXVX.mjs';

package/dist/{chunk-O3FX3SD4.mjs → chunk-V4NPLS4E.mjs}

@@ -146,6 +146,22 @@ function minLength(requirement, message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
+function minValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
 function regex(requirement, message$1) {
   return {
     kind: "validation",
@@ -162,6 +178,22 @@ function regex(requirement, message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
+function safeInteger(message$1) {
+  return {
+    kind: "validation",
+    type: "safe_integer",
+    reference: safeInteger,
+    async: false,
+    expects: null,
+    requirement: Number.isSafeInteger,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "safe integer", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
 function getFallback(schema, dataset, config$1) {
   return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
 }
@@ -582,4 +614,4 @@ function summarize(issues) {
   return summary;
 }
 
-export { array, check, custom, getDotPath, instance, literal, maxLength, minLength, nullable, number, object, optional, picklist, pipe, record, regex, safeParse, string, summarize, union, unknown };
+export { array, check, custom, getDotPath, instance, literal, maxLength, minLength, minValue, nullable, number, object, optional, picklist, pipe, record, regex, safeInteger, safeParse, string, summarize, union, unknown };

package/dist/{chunk-ZAUHAJ4G.mjs → chunk-ZD5FP3IW.mjs}

@@ -13,6 +13,7 @@ var DEVICE_CURSORS_TABLE = "_sirannon_device_cursors";
 var STAGED_CHANGES_TABLE = "_sirannon_staged_changes";
 var STAGED_PUSH_CHANGES_TABLE = "_sirannon_staged_push_changes";
 var REPLACED_ROWS_TABLE = "_sirannon_replaced_rows";
+var ROLLED_BACK_CHANGES_TABLE = "_sirannon_rolled_back_changes";
 var CDC_TRIGGER_PREFIX = "_sirannon_trg_";
 var LIVE_PROBE_TABLE_PREFIX = "_sirannon_live_probe_";
 var KEY_CHANGE_CAPTURE_PREFIX = "_sirannon_key_change_";
@@ -302,4 +303,4 @@ function decodeHexBytes(hex) {
   return bytes;
 }
 
-export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, INTERNAL_TABLE_PREFIX, KEY_CHANGE_CAPTURE_PREFIX, LIVE_PROBE_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, REPLACED_ROWS_TABLE, SAFE_INT_BOUND_TEXT, STAGED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, SYNC_STATE_TABLE, assertSqlAllowed, changedAtToEventTimestamp, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, eventTimestampToChangedAt, isReservedIdentifier };
+export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, INTERNAL_TABLE_PREFIX, KEY_CHANGE_CAPTURE_PREFIX, LIVE_PROBE_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, REPLACED_ROWS_TABLE, ROLLED_BACK_CHANGES_TABLE, SAFE_INT_BOUND_TEXT, STAGED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, SYNC_STATE_TABLE, assertSqlAllowed, changedAtToEventTimestamp, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, eventTimestampToChangedAt, isReservedIdentifier };

package/dist/codegen/cli.mjs

@@ -1,9 +1,9 @@
-import { runCodegen } from '../chunk-RWPKDNT3.mjs';
+import { runCodegen } from '../chunk-K3Z4TEP2.mjs';
 import '../chunk-D3YF2G7X.mjs';
 import '../chunk-KB4OLJAD.mjs';
 import '../chunk-SEL4A4WT.mjs';
 import '../chunk-GVCNMPOS.mjs';
-import '../chunk-O3FX3SD4.mjs';
+import '../chunk-V4NPLS4E.mjs';
 import '../chunk-KINDFBQP.mjs';
 
 // src/codegen/cli.ts

package/dist/codegen/index.mjs

@@ -1,7 +1,7 @@
-export { CODEGEN_USAGE, OPERATION_MANIFEST_VERSION, buildOperationManifest, parseOperationManifest, renderGoOperations, renderOperationTypes, renderPythonOperations, runCodegen, selectColumns } from '../chunk-RWPKDNT3.mjs';
+export { CODEGEN_USAGE, OPERATION_MANIFEST_VERSION, buildOperationManifest, parseOperationManifest, renderGoOperations, renderOperationTypes, renderPythonOperations, runCodegen, selectColumns } from '../chunk-K3Z4TEP2.mjs';
 import '../chunk-D3YF2G7X.mjs';
 import '../chunk-KB4OLJAD.mjs';
 import '../chunk-SEL4A4WT.mjs';
 import '../chunk-GVCNMPOS.mjs';
-import '../chunk-O3FX3SD4.mjs';
+import '../chunk-V4NPLS4E.mjs';
 import '../chunk-KINDFBQP.mjs';

package/dist/core/index.mjs

@@ -1,19 +1,19 @@
-import { Transaction, MetricsCollector, readOutcome, failedStatementOutcome, settleLateOutcome, ROW_COUNTS_UNKNOWN, leavesOutcomeUnknown, LWWResolver, REMOTE_ORIGIN_NODE_ID, BatchReader, BatchApplier, recordLocalColumnVersions, writeOutcome, batchWriteOutcome, StatementRecorder, loadPersistedHlc, isWellFormedHlc, HLC_CLOCK_META_KEY, readOneOutcome } from '../chunk-VKCUSREW.mjs';
-export { MetricsCollector, Transaction } from '../chunk-VKCUSREW.mjs';
-import { executeGroup } from '../chunk-ULUZUBON.mjs';
-import { query, queryRowsForWire, queryOne, asQueryError, runInSavepoint, runWriterTransaction, withoutRowCounts, execute, executeBatchSummary, bindParams, executeBatch, queryMetered, queryForWire, queryOneMetered } from '../chunk-ZWW53O5P.mjs';
-export { execute, executeBatch, query, queryOne } from '../chunk-ZWW53O5P.mjs';
+import { Transaction, MetricsCollector, readOutcome, failedStatementOutcome, settleLateOutcome, ROW_COUNTS_UNKNOWN, leavesOutcomeUnknown, LWWResolver, REMOTE_ORIGIN_NODE_ID, BatchReader, BatchApplier, recordLocalColumnVersions, writeOutcome, batchWriteOutcome, StatementRecorder, loadPersistedHlc, isWellFormedHlc, HLC_CLOCK_META_KEY, readOneOutcome } from '../chunk-PR2APVRF.mjs';
+export { MetricsCollector, Transaction } from '../chunk-PR2APVRF.mjs';
+import { executeGroup } from '../chunk-DQ5EB7CS.mjs';
+import { query, queryRowsForWire, queryOne, asQueryError, runInSavepoint, runWriterTransaction, withoutRowCounts, execute, executeBatchSummary, bindParams, executeBatch, queryMetered, queryForWire, queryOneMetered } from '../chunk-C3OVUSZP.mjs';
+export { execute, executeBatch, query, queryOne } from '../chunk-C3OVUSZP.mjs';
 import { unsupported, findClauses, readSource, readSortTerms, readWindow, readSelectItems } from '../chunk-D3YF2G7X.mjs';
-import { reconcileMigrationChecksums, migrationContentChecksum, resolveDeviceRetentionPolicy, ensureCdcEpoch, SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling, DEVICE_SYNC_PUSHED_SEQ_META_KEY, runBulkLoad, parseColumnDefinitions, dropMainSchemaTriggers, createMainSchemaTriggers, TransactionGrouper, PrimedSubscription, dropCdcTriggers, escId, ROWID_ALIASES, installKeyChangeCaptureTriggers, dropKeyChangeCaptureTriggers } from '../chunk-2ZQOZFX7.mjs';
-export { ChangeTracker, isBulkLoadDurability, runBulkLoad } from '../chunk-2ZQOZFX7.mjs';
-import { EncryptionKeyring, planBackupRestore, backupPiecesSafeToDelete, resolveEncryptionKey, wipeEncryptionKey } from '../chunk-GCOJFQOL.mjs';
-export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-GCOJFQOL.mjs';
-import { ensureMigrationsTable, prepareUpdateMigrationChecksum, prepareInsertMigration, selectAppliedMigrationsNewestFirst, prepareDeleteMigration, selectAppliedMigrations, selectTableExists, selectMetaValue, deleteMetaValue, ensureMetaTable, upsertMetaValue, SEQ_STRING_RE, replaceMigrationHistory, highestMigrationVersion, selectCountOutboundChanges, ensureChangesTable, ensureBatchApplyTables, ensureStagedPushChangesTable, PkResolver, selectMaxChangeSeq, selectMaxAppliedSourceSeq, tableColumnsWithGenerated, TABLE_XINFO_HIDDEN, selectTableSql, primaryKeyColumns, tableIndexList, upsertMetaMaxChangeSeqSql, updateChangeStampsAboveMetaSeqSql, upsertMetaValueAndMaxChangeSeqSql, insertMetaValueIfAbsent, HLC, selectMaxChangeHlc, setForeignKeysEnabled, IDENTIFIER_RE, validateDdlSafety, ensureStagedChangesTable, upsertStagedChangeSql, selectFirstStagedTransactionEnd, deleteStagedChangesUpToSeq, selectMaxStagedSeq, deleteAllStagedChanges, selectStagedChangesInRange, assertSafeIdentifier } from '../chunk-MTOQ6QIS.mjs';
+import { reconcileMigrationChecksums, migrationContentChecksum, resolveDeviceRetentionPolicy, ensureCdcEpoch, SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling, DEVICE_SYNC_PUSHED_SEQ_META_KEY, runBulkLoad, parseColumnDefinitions, dropMainSchemaTriggers, createMainSchemaTriggers, TransactionGrouper, PrimedSubscription, dropCdcTriggers, escId, ROWID_ALIASES, installKeyChangeCaptureTriggers, dropKeyChangeCaptureTriggers } from '../chunk-S36XLMIW.mjs';
+export { ChangeTracker, isBulkLoadDurability, runBulkLoad } from '../chunk-S36XLMIW.mjs';
+import { EncryptionKeyring, planBackupRestore, backupPiecesSafeToDelete, resolveEncryptionKey, wipeEncryptionKey } from '../chunk-EOESJH5I.mjs';
+export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-EOESJH5I.mjs';
+import { ensureMigrationsTable, prepareUpdateMigrationChecksum, prepareInsertMigration, selectAppliedMigrationsNewestFirst, prepareDeleteMigration, selectAppliedMigrations, selectTableExists, selectMetaValue, deleteMetaValue, ensureMetaTable, upsertMetaValue, SEQ_STRING_RE, replaceMigrationHistory, highestMigrationVersion, selectCountOutboundChanges, ensureChangesTable, ensureBatchApplyTables, ensureStagedPushChangesTable, PkResolver, selectMaxChangeSeq, selectMaxAppliedSourceSeq, tableColumnsWithGenerated, TABLE_XINFO_HIDDEN, selectTableSql, primaryKeyColumns, tableIndexList, upsertMetaMaxChangeSeqSql, updateChangeStampsAboveMetaSeqSql, upsertMetaValueAndMaxChangeSeqSql, insertMetaValueIfAbsent, HLC, selectMaxChangeHlc, setForeignKeysEnabled, IDENTIFIER_RE, validateDdlSafety, ensureStagedChangesTable, upsertStagedChangeSql, selectFirstStagedTransactionEnd, deleteStagedChangesUpToSeq, selectMaxStagedSeq, deleteAllStagedChanges, selectStagedChangesInRange, assertSafeIdentifier } from '../chunk-2EYLKZZY.mjs';
 import { ReplicationError } from '../chunk-BLMRNSUG.mjs';
-import { MIGRATIONS_TABLE, META_TABLE, CHANGES_TABLE, assertSqlAllowed, LIVE_PROBE_TABLE_PREFIX, eventTimestampToChangedAt, encodeTaggedValues, INTERNAL_TABLE_PREFIX, isReservedIdentifier, decodeTaggedValues, changedAtToEventTimestamp, KEY_CHANGE_CAPTURE_PREFIX } from '../chunk-ZAUHAJ4G.mjs';
+import { MIGRATIONS_TABLE, META_TABLE, CHANGES_TABLE, assertSqlAllowed, LIVE_PROBE_TABLE_PREFIX, eventTimestampToChangedAt, encodeTaggedValues, INTERNAL_TABLE_PREFIX, isReservedIdentifier, decodeTaggedValues, changedAtToEventTimestamp, KEY_CHANGE_CAPTURE_PREFIX } from '../chunk-ZD5FP3IW.mjs';
 import { tokenizeSql, isKeyword, parameterName } from '../chunk-SEL4A4WT.mjs';
 import '../chunk-GVCNMPOS.mjs';
-import '../chunk-O3FX3SD4.mjs';
+import '../chunk-V4NPLS4E.mjs';
 import { defaultStagingDir } from '../chunk-Y4SP7CRF.mjs';
 import { startCopyWithoutHoldingWriter, readMainDatabasePath } from '../chunk-I4JY5QPA.mjs';
 import { lateRowCountsOf, lateGroupOutcomesOf, withoutLateRowCounts, withLateRowCounts } from '../chunk-K43WJORM.mjs';

package/dist/core/writer-worker.mjs

@@ -1,6 +1,6 @@
-import { executeGroup } from '../chunk-ULUZUBON.mjs';
-import '../chunk-ZWW53O5P.mjs';
-import '../chunk-ZAUHAJ4G.mjs';
+import { executeGroup } from '../chunk-DQ5EB7CS.mjs';
+import '../chunk-C3OVUSZP.mjs';
+import '../chunk-ZD5FP3IW.mjs';
 import { WORKER_CANCELLED_CODE, serializeError, WORKER_BEGIN_FAILED_CODE, WORKER_COPY_STOPPED_CODE } from '../chunk-75IBRE73.mjs';
 import { addRowCounts, rowCountsOf, withRowCounts } from '../chunk-E2GRX4ZD.mjs';
 import { SirannonError } from '../chunk-KINDFBQP.mjs';

package/dist/replication/coordinator/etcd.d.ts

@@ -1,5 +1,5 @@
 import { IOptions } from 'etcd3';
-import { C as ClusterCoordinator, A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, b as ControllerLeaseWatcher, c as CoordinatorWatchDisposer, R as RegisterNodeSessionInput, d as CoordinatorNodeSession, N as NodeSessionWatcher, S as SetReplicationGroupStateInput, e as ReplicationGroupState, f as CreateReplicationGroupStateResult, g as AddVoterInput, V as VoterChangeResult, h as RemoveVoterInput, i as ReplicationGroupWatcher, j as CompareAndAdvancePrimaryTermInput, k as CompareAndAdvancePrimaryTermResult, U as UpdateInSyncSetInput, l as AdmitNodeToInSyncSetInput, m as UpdateNodeMaintenanceInput, P as PromoteEligibleReplicaInput } from '../../types-MczwKtul.js';
+import { C as ClusterCoordinator, A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, b as ControllerLeaseWatcher, c as CoordinatorWatchDisposer, R as RegisterNodeSessionInput, d as CoordinatorNodeSession, N as NodeSessionWatcher, S as SetReplicationGroupStateInput, e as ReplicationGroupState, f as CreateReplicationGroupStateResult, g as AddVoterInput, V as VoterChangeResult, h as RemoveVoterInput, i as RaiseFeatureLevelInput, j as ReplicationGroupWatcher, k as CompareAndAdvancePrimaryTermInput, l as CompareAndAdvancePrimaryTermResult, U as UpdateInSyncSetInput, m as AdmitNodeToInSyncSetInput, n as UpdateNodeMaintenanceInput, P as PromoteEligibleReplicaInput } from '../../types-qJL9h6Qe.js';
 
 /**
  * Sets the etcd endpoints that the etcd coordinator connects to, the key prefix that it stores group state under, and
@@ -94,6 +94,8 @@ declare class EtcdClusterCoordinator implements ClusterCoordinator {
     addVoter(input: AddVoterInput): Promise<VoterChangeResult>;
     /** Removes a voter or a pending voter from the group, while the group's voters match the expected list. */
     removeVoter(input: RemoveVoterInput): Promise<VoterChangeResult>;
+    /** Raises the group's feature level, while every member holds a live session that supports the new level. */
+    raiseFeatureLevel(input: RaiseFeatureLevelInput): Promise<ReplicationGroupState | null>;
     /** Returns the group's state, or null when etcd has no state for the group. */
     getReplicationGroupState(clusterId: string, groupId: string): Promise<ReplicationGroupState | null>;
     /** Calls `watcher` with the new state after each change to the group, and returns a function that stops the watch. */