@voidhash/mimic 0.0.2 → 0.0.4

package/dist/client/Rebase.mjs

@@ -0,0 +1,198 @@
+import { __export } from "../_virtual/rolldown_runtime.mjs";
+import { isPrefix, pathsEqual, pathsOverlap } from "../OperationPath.mjs";
+
+//#region src/client/Rebase.ts
+var Rebase_exports = /* @__PURE__ */ __export({
+	rebaseAfterRejection: () => rebaseAfterRejection,
+	rebaseAfterRejectionWithPrimitive: () => rebaseAfterRejectionWithPrimitive,
+	rebasePendingTransactions: () => rebasePendingTransactions,
+	rebasePendingTransactionsWithPrimitive: () => rebasePendingTransactionsWithPrimitive,
+	transformOperation: () => transformOperation,
+	transformOperationWithPrimitive: () => transformOperationWithPrimitive,
+	transformTransaction: () => transformTransaction,
+	transformTransactionWithPrimitive: () => transformTransactionWithPrimitive
+});
+/**
+* Transforms a client operation against a server operation using a primitive.
+* 
+* This delegates to the primitive's transformOperation method, which handles
+* type-specific conflict resolution.
+* 
+* @param clientOp - The client's operation to transform
+* @param serverOp - The server's operation that has already been applied
+* @param primitive - The root primitive to use for transformation
+* @returns TransformResult indicating how the client operation should be handled
+*/
+const transformOperationWithPrimitive = (clientOp, serverOp, primitive) => {
+	return primitive._internal.transformOperation(clientOp, serverOp);
+};
+/**
+* Transforms a client operation against a server operation.
+*
+* This is a standalone implementation for cases where the primitive is not available.
+* For schema-aware transformation, use transformOperationWithPrimitive instead.
+*
+* The key principle: client ops "shadow" server ops for the same path,
+* meaning if both touch the same field, the client's intention wins
+* (since it was made with knowledge of the server state at that time).
+*/
+const transformOperation = (clientOp, serverOp) => {
+	const clientPath = clientOp.path;
+	const serverPath = serverOp.path;
+	if (!pathsOverlap(clientPath, serverPath)) return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (serverOp.kind === "array.remove") {
+		const removedId = serverOp.payload.id;
+		const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+		const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+		if (clientTokens.length > serverTokens.length) {
+			if (clientTokens[serverTokens.length] === removedId) return { type: "noop" };
+		}
+	}
+	if (serverOp.kind === "array.insert" && clientOp.kind === "array.insert") return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (serverOp.kind === "array.move" && clientOp.kind === "array.move") {
+		if (serverOp.payload.id === clientOp.payload.id) return {
+			type: "transformed",
+			operation: clientOp
+		};
+		return {
+			type: "transformed",
+			operation: clientOp
+		};
+	}
+	if (pathsEqual(clientPath, serverPath)) return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (isPrefix(serverPath, clientPath)) {
+		const serverKind = serverOp.kind;
+		if (serverKind === "struct.set" || serverKind === "array.set" || serverKind === "union.set") return {
+			type: "transformed",
+			operation: clientOp
+		};
+	}
+	return {
+		type: "transformed",
+		operation: clientOp
+	};
+};
+/**
+* Transforms all operations in a client transaction against a server transaction.
+* Uses the primitive's transformOperation for schema-aware transformation.
+*/
+const transformTransactionWithPrimitive = (clientTx, serverTx, primitive) => {
+	const transformedOps = [];
+	for (const clientOp of clientTx.ops) {
+		let currentOp = clientOp;
+		for (const serverOp of serverTx.ops) {
+			if (currentOp === null) break;
+			const result = transformOperationWithPrimitive(currentOp, serverOp, primitive);
+			switch (result.type) {
+				case "transformed":
+					currentOp = result.operation;
+					break;
+				case "noop":
+					currentOp = null;
+					break;
+				case "conflict": break;
+			}
+		}
+		if (currentOp !== null) transformedOps.push(currentOp);
+	}
+	return {
+		id: clientTx.id,
+		ops: transformedOps,
+		timestamp: clientTx.timestamp
+	};
+};
+/**
+* Transforms all operations in a client transaction against a server transaction.
+* This is a standalone version that doesn't require a primitive.
+*/
+const transformTransaction = (clientTx, serverTx) => {
+	const transformedOps = [];
+	for (const clientOp of clientTx.ops) {
+		let currentOp = clientOp;
+		for (const serverOp of serverTx.ops) {
+			if (currentOp === null) break;
+			const result = transformOperation(currentOp, serverOp);
+			switch (result.type) {
+				case "transformed":
+					currentOp = result.operation;
+					break;
+				case "noop":
+					currentOp = null;
+					break;
+				case "conflict": break;
+			}
+		}
+		if (currentOp !== null) transformedOps.push(currentOp);
+	}
+	return {
+		id: clientTx.id,
+		ops: transformedOps,
+		timestamp: clientTx.timestamp
+	};
+};
+/**
+* Rebases a list of pending transactions against a server transaction using a primitive.
+*
+* This is called when a server transaction arrives that is NOT one of our pending
+* transactions. We need to transform all pending transactions to work correctly
+* on top of the new server state.
+*/
+const rebasePendingTransactionsWithPrimitive = (pendingTxs, serverTx, primitive) => {
+	return pendingTxs.map((pendingTx) => transformTransactionWithPrimitive(pendingTx, serverTx, primitive));
+};
+/**
+* Rebases a list of pending transactions against a server transaction.
+*
+* This is called when a server transaction arrives that is NOT one of our pending
+* transactions. We need to transform all pending transactions to work correctly
+* on top of the new server state.
+*/
+const rebasePendingTransactions = (pendingTxs, serverTx) => {
+	return pendingTxs.map((pendingTx) => transformTransaction(pendingTx, serverTx));
+};
+/**
+* Rebases pending transactions after a rejection using a primitive.
+*
+* When a transaction is rejected, we need to re-transform remaining pending
+* transactions as if the rejected transaction never happened. This is done by
+* rebuilding from the original operations against the current server state.
+*
+* @param originalPendingTxs - The original pending transactions before any rebasing
+* @param rejectedTxId - ID of the rejected transaction
+* @param serverTxsSinceOriginal - Server transactions that have arrived since original
+* @param primitive - The root primitive to use for transformation
+*/
+const rebaseAfterRejectionWithPrimitive = (originalPendingTxs, rejectedTxId, serverTxsSinceOriginal, primitive) => {
+	let result = [...originalPendingTxs.filter((tx) => tx.id !== rejectedTxId)];
+	for (const serverTx of serverTxsSinceOriginal) result = rebasePendingTransactionsWithPrimitive(result, serverTx, primitive);
+	return result;
+};
+/**
+* Rebases pending transactions after a rejection.
+*
+* When a transaction is rejected, we need to re-transform remaining pending
+* transactions as if the rejected transaction never happened. This is done by
+* rebuilding from the original operations against the current server state.
+*
+* @param originalPendingTxs - The original pending transactions before any rebasing
+* @param rejectedTxId - ID of the rejected transaction
+* @param serverTxsSinceOriginal - Server transactions that have arrived since original
+*/
+const rebaseAfterRejection = (originalPendingTxs, rejectedTxId, serverTxsSinceOriginal) => {
+	let result = [...originalPendingTxs.filter((tx) => tx.id !== rejectedTxId)];
+	for (const serverTx of serverTxsSinceOriginal) result = rebasePendingTransactions(result, serverTx);
+	return result;
+};
+
+//#endregion
+export { Rebase_exports, rebaseAfterRejectionWithPrimitive, transformTransactionWithPrimitive };
+//# sourceMappingURL=Rebase.mjs.map

package/dist/client/Rebase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rebase.mjs","names":["OperationPath.pathsOverlap","OperationPath.pathsEqual","OperationPath.isPrefix","transformedOps: Operation.Operation<any, any, any>[]","currentOp: Operation.Operation<any, any, any> | null"],"sources":["../../src/client/Rebase.ts"],"sourcesContent":["import type * as Operation from \"../Operation\";\nimport type * as Transaction from \"../Transaction\";\nimport type * as Primitive from \"../Primitive\";\nimport * as OperationPath from \"../OperationPath\";\nimport * as Transform from \"../Transform\";\n\n// =============================================================================\n// Re-export Transform types from mimic for backwards compatibility\n// =============================================================================\n\nexport type TransformResult = Transform.TransformResult;\n\n// =============================================================================\n// Operation Transformation\n// =============================================================================\n\n/**\n * Transforms a client operation against a server operation using a primitive.\n * \n * This delegates to the primitive's transformOperation method, which handles\n * type-specific conflict resolution.\n * \n * @param clientOp - The client's operation to transform\n * @param serverOp - The server's operation that has already been applied\n * @param primitive - The root primitive to use for transformation\n * @returns TransformResult indicating how the client operation should be handled\n */\nexport const transformOperationWithPrimitive = (\n  clientOp: Operation.Operation<any, any, any>,\n  serverOp: Operation.Operation<any, any, any>,\n  primitive: Primitive.AnyPrimitive\n): TransformResult => {\n  return primitive._internal.transformOperation(clientOp, serverOp);\n};\n\n/**\n * Transforms a client operation against a server operation.\n *\n * This is a standalone implementation for cases where the primitive is not available.\n * For schema-aware transformation, use transformOperationWithPrimitive instead.\n *\n * The key principle: client ops \"shadow\" server ops for the same path,\n * meaning if both touch the same field, the client's intention wins\n * (since it was made with knowledge of the server state at that time).\n */\nexport const transformOperation = (\n  clientOp: Operation.Operation<any, any, any>,\n  serverOp: Operation.Operation<any, any, any>\n): TransformResult => {\n  const clientPath = clientOp.path;\n  const serverPath = serverOp.path;\n\n  // If paths don't overlap at all, no transformation needed\n  if (!OperationPath.pathsOverlap(clientPath, serverPath)) {\n    return { type: \"transformed\", operation: clientOp };\n  }\n\n  // Handle array operations specially\n  if (serverOp.kind === \"array.remove\") {\n    // If server removed an array element that client is operating on\n    const removedId = (serverOp.payload as { id: string }).id;\n    const clientTokens = clientPath.toTokens().filter((t: string) => t !== \"\");\n    const serverTokens = serverPath.toTokens().filter((t: string) => t !== \"\");\n\n    // Check if client is operating on the removed element or its children\n    if (clientTokens.length > serverTokens.length) {\n      const elementId = clientTokens[serverTokens.length];\n      if (elementId === removedId) {\n        // Client operation targets a removed element - becomes noop\n        return { type: \"noop\" };\n      }\n    }\n  }\n\n  if (serverOp.kind === \"array.insert\" && clientOp.kind === \"array.insert\") {\n    // Both inserting into same array - positions are independent (fractional indexing)\n    // No transformation needed as fractional indices handle ordering\n    return { type: \"transformed\", operation: clientOp };\n  }\n\n  if (serverOp.kind === \"array.move\" && clientOp.kind === \"array.move\") {\n    // Both moving elements - if same element, client wins (last-write-wins for position)\n    const serverMoveId = (serverOp.payload as { id: string }).id;\n    const clientMoveId = (clientOp.payload as { id: string }).id;\n\n    if (serverMoveId === clientMoveId) {\n      // Client's move supersedes server's move\n      return { type: \"transformed\", operation: clientOp };\n    }\n    // Different elements - no conflict\n    return { type: \"transformed\", operation: clientOp };\n  }\n\n  // For set operations on the same exact path: client wins (last-write-wins)\n  if (OperationPath.pathsEqual(clientPath, serverPath)) {\n    // Both operations target the same path\n    // Client operation was made with intent to set this value,\n    // so it should override the server's change\n    return { type: \"transformed\", operation: clientOp };\n  }\n\n  // If server set a parent path, client's child operation might be invalid\n  if (OperationPath.isPrefix(serverPath, clientPath)) {\n    const serverKind = serverOp.kind;\n    if (\n      serverKind === \"struct.set\" ||\n      serverKind === \"array.set\" ||\n      serverKind === \"union.set\"\n    ) {\n      // Server replaced the entire parent - client's child op may be invalid\n      // However, for optimistic updates, we let the client op proceed\n      // and the server will validate/reject if needed\n      return { type: \"transformed\", operation: clientOp };\n    }\n  }\n\n  // Default: no transformation needed, client op proceeds as-is\n  return { type: \"transformed\", operation: clientOp };\n};\n\n/**\n * Transforms all operations in a client transaction against a server transaction.\n * Uses the primitive's transformOperation for schema-aware transformation.\n */\nexport const transformTransactionWithPrimitive = (\n  clientTx: Transaction.Transaction,\n  serverTx: Transaction.Transaction,\n  primitive: Primitive.AnyPrimitive\n): Transaction.Transaction => {\n  const transformedOps: Operation.Operation<any, any, any>[] = [];\n\n  for (const clientOp of clientTx.ops) {\n    let currentOp: Operation.Operation<any, any, any> | null = clientOp;\n\n    // Transform against each server operation\n    for (const serverOp of serverTx.ops) {\n      if (currentOp === null) break;\n\n      const result = transformOperationWithPrimitive(currentOp, serverOp, primitive);\n\n      switch (result.type) {\n        case \"transformed\":\n          currentOp = result.operation;\n          break;\n        case \"noop\":\n          currentOp = null;\n          break;\n        case \"conflict\":\n          // For now, treat conflicts as the client op proceeding\n          // Server will ultimately validate\n          break;\n      }\n    }\n\n    if (currentOp !== null) {\n      transformedOps.push(currentOp);\n    }\n  }\n\n  // Return a new transaction with the same ID but transformed ops\n  return {\n    id: clientTx.id,\n    ops: transformedOps,\n    timestamp: clientTx.timestamp,\n  };\n};\n\n/**\n * Transforms all operations in a client transaction against a server transaction.\n * This is a standalone version that doesn't require a primitive.\n */\nexport const transformTransaction = (\n  clientTx: Transaction.Transaction,\n  serverTx: Transaction.Transaction\n): Transaction.Transaction => {\n  const transformedOps: Operation.Operation<any, any, any>[] = [];\n\n  for (const clientOp of clientTx.ops) {\n    let currentOp: Operation.Operation<any, any, any> | null = clientOp;\n\n    // Transform against each server operation\n    for (const serverOp of serverTx.ops) {\n      if (currentOp === null) break;\n\n      const result = transformOperation(currentOp, serverOp);\n\n      switch (result.type) {\n        case \"transformed\":\n          currentOp = result.operation;\n          break;\n        case \"noop\":\n          currentOp = null;\n          break;\n        case \"conflict\":\n          // For now, treat conflicts as the client op proceeding\n          // Server will ultimately validate\n          break;\n      }\n    }\n\n    if (currentOp !== null) {\n      transformedOps.push(currentOp);\n    }\n  }\n\n  // Return a new transaction with the same ID but transformed ops\n  return {\n    id: clientTx.id,\n    ops: transformedOps,\n    timestamp: clientTx.timestamp,\n  };\n};\n\n/**\n * Rebases a list of pending transactions against a server transaction using a primitive.\n *\n * This is called when a server transaction arrives that is NOT one of our pending\n * transactions. We need to transform all pending transactions to work correctly\n * on top of the new server state.\n */\nexport const rebasePendingTransactionsWithPrimitive = (\n  pendingTxs: ReadonlyArray<Transaction.Transaction>,\n  serverTx: Transaction.Transaction,\n  primitive: Primitive.AnyPrimitive\n): Transaction.Transaction[] => {\n  return pendingTxs.map((pendingTx) =>\n    transformTransactionWithPrimitive(pendingTx, serverTx, primitive)\n  );\n};\n\n/**\n * Rebases a list of pending transactions against a server transaction.\n *\n * This is called when a server transaction arrives that is NOT one of our pending\n * transactions. We need to transform all pending transactions to work correctly\n * on top of the new server state.\n */\nexport const rebasePendingTransactions = (\n  pendingTxs: ReadonlyArray<Transaction.Transaction>,\n  serverTx: Transaction.Transaction\n): Transaction.Transaction[] => {\n  return pendingTxs.map((pendingTx) =>\n    transformTransaction(pendingTx, serverTx)\n  );\n};\n\n/**\n * Rebases pending transactions after a rejection using a primitive.\n *\n * When a transaction is rejected, we need to re-transform remaining pending\n * transactions as if the rejected transaction never happened. This is done by\n * rebuilding from the original operations against the current server state.\n *\n * @param originalPendingTxs - The original pending transactions before any rebasing\n * @param rejectedTxId - ID of the rejected transaction\n * @param serverTxsSinceOriginal - Server transactions that have arrived since original\n * @param primitive - The root primitive to use for transformation\n */\nexport const rebaseAfterRejectionWithPrimitive = (\n  originalPendingTxs: ReadonlyArray<Transaction.Transaction>,\n  rejectedTxId: string,\n  serverTxsSinceOriginal: ReadonlyArray<Transaction.Transaction>,\n  primitive: Primitive.AnyPrimitive\n): Transaction.Transaction[] => {\n  // Filter out the rejected transaction\n  const remainingOriginals = originalPendingTxs.filter(\n    (tx) => tx.id !== rejectedTxId\n  );\n\n  // Re-transform each remaining transaction against all server transactions\n  let result = [...remainingOriginals];\n\n  for (const serverTx of serverTxsSinceOriginal) {\n    result = rebasePendingTransactionsWithPrimitive(result, serverTx, primitive);\n  }\n\n  return result;\n};\n\n/**\n * Rebases pending transactions after a rejection.\n *\n * When a transaction is rejected, we need to re-transform remaining pending\n * transactions as if the rejected transaction never happened. This is done by\n * rebuilding from the original operations against the current server state.\n *\n * @param originalPendingTxs - The original pending transactions before any rebasing\n * @param rejectedTxId - ID of the rejected transaction\n * @param serverTxsSinceOriginal - Server transactions that have arrived since original\n */\nexport const rebaseAfterRejection = (\n  originalPendingTxs: ReadonlyArray<Transaction.Transaction>,\n  rejectedTxId: string,\n  serverTxsSinceOriginal: ReadonlyArray<Transaction.Transaction>\n): Transaction.Transaction[] => {\n  // Filter out the rejected transaction\n  const remainingOriginals = originalPendingTxs.filter(\n    (tx) => tx.id !== rejectedTxId\n  );\n\n  // Re-transform each remaining transaction against all server transactions\n  let result = [...remainingOriginals];\n\n  for (const serverTx of serverTxsSinceOriginal) {\n    result = rebasePendingTransactions(result, serverTx);\n  }\n\n  return result;\n};\n"],"mappings":"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"}

package/dist/client/StateMonitor.cjs

@@ -0,0 +1,133 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+
+//#region src/client/StateMonitor.ts
+var StateMonitor_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	determineRecoveryAction: () => determineRecoveryAction,
+	make: () => make
+});
+/**
+* Creates a new StateMonitor.
+*/
+const make = (options = {}) => {
+	const { onEvent, healthCheckInterval = 5e3, stalePendingThreshold = 1e4, maxVersionGap = 10 } = options;
+	let _expectedVersion = 0;
+	let _pendingMap = /* @__PURE__ */ new Map();
+	let _isRecovering = false;
+	let _healthCheckHandle = null;
+	/**
+	* Emits an event if handler is provided.
+	*/
+	const emit = (event) => {
+		onEvent === null || onEvent === void 0 || onEvent(event);
+	};
+	/**
+	* Checks if there's a version gap indicating drift.
+	*/
+	const checkVersionGap = (receivedVersion) => {
+		const expectedNext = _expectedVersion + 1;
+		if (receivedVersion < expectedNext) return true;
+		if (receivedVersion > expectedNext + maxVersionGap) {
+			emit({
+				type: "drift_detected",
+				expectedVersion: expectedNext,
+				receivedVersion
+			});
+			return false;
+		}
+		return true;
+	};
+	/**
+	* Runs a health check.
+	*/
+	const runHealthCheck = () => {
+		const now = Date.now();
+		let oldestPendingMs = null;
+		for (const [id, info] of _pendingMap) {
+			const elapsed = now - info.sentAt;
+			if (oldestPendingMs === null || elapsed > oldestPendingMs) oldestPendingMs = elapsed;
+			if (elapsed > stalePendingThreshold) emit({
+				type: "pending_timeout",
+				transactionId: id,
+				elapsedMs: elapsed
+			});
+		}
+		emit({
+			type: "health_check",
+			pendingCount: _pendingMap.size,
+			oldestPendingMs
+		});
+	};
+	return {
+		onServerVersion: (version) => {
+			const isValid = checkVersionGap(version);
+			if (isValid) _expectedVersion = Math.max(_expectedVersion, version);
+			return isValid;
+		},
+		trackPending: (info) => {
+			_pendingMap.set(info.id, info);
+		},
+		untrackPending: (id) => {
+			_pendingMap.delete(id);
+		},
+		getStalePending: () => {
+			const now = Date.now();
+			const stale = [];
+			for (const info of _pendingMap.values()) if (now - info.sentAt > stalePendingThreshold) stale.push(info);
+			return stale;
+		},
+		getStatus: () => {
+			const now = Date.now();
+			let oldestPendingMs = null;
+			for (const info of _pendingMap.values()) {
+				const elapsed = now - info.sentAt;
+				if (oldestPendingMs === null || elapsed > oldestPendingMs) oldestPendingMs = elapsed;
+			}
+			const isHealthy = !_isRecovering && (oldestPendingMs === null || oldestPendingMs < stalePendingThreshold * 2);
+			return {
+				expectedVersion: _expectedVersion,
+				pendingCount: _pendingMap.size,
+				oldestPendingMs,
+				isHealthy,
+				isRecovering: _isRecovering
+			};
+		},
+		start: () => {
+			if (_healthCheckHandle !== null) return;
+			_healthCheckHandle = setInterval(runHealthCheck, healthCheckInterval);
+		},
+		stop: () => {
+			if (_healthCheckHandle !== null) {
+				clearInterval(_healthCheckHandle);
+				_healthCheckHandle = null;
+			}
+		},
+		reset: (newVersion) => {
+			_expectedVersion = newVersion;
+			_pendingMap.clear();
+			_isRecovering = false;
+			emit({
+				type: "recovery_completed",
+				version: newVersion
+			});
+		}
+	};
+};
+/**
+* Determines the appropriate recovery action based on current state.
+*/
+const determineRecoveryAction = (status, stalePending) => {
+	if (!status.isHealthy || stalePending.length > 3) return { type: "request_snapshot" };
+	if (stalePending.length > 0) return {
+		type: "drop_pending",
+		transactionIds: stalePending.map((p) => p.id)
+	};
+	return { type: "request_snapshot" };
+};
+
+//#endregion
+Object.defineProperty(exports, 'StateMonitor_exports', {
+  enumerable: true,
+  get: function () {
+    return StateMonitor_exports;
+  }
+});

package/dist/client/StateMonitor.d.cts

@@ -0,0 +1,122 @@
+declare namespace StateMonitor_d_exports {
+  export { PendingInfo, RecoveryAction, StateMonitor, StateMonitorEvent, StateMonitorEventHandler, StateMonitorOptions, StateMonitorStatus, determineRecoveryAction, make };
+}
+/**
+ * Events emitted by the state monitor.
+ */
+type StateMonitorEvent = {
+  type: "drift_detected";
+  expectedVersion: number;
+  receivedVersion: number;
+} | {
+  type: "recovery_started";
+} | {
+  type: "recovery_completed";
+  version: number;
+} | {
+  type: "recovery_failed";
+  error: Error;
+} | {
+  type: "pending_timeout";
+  transactionId: string;
+  elapsedMs: number;
+} | {
+  type: "health_check";
+  pendingCount: number;
+  oldestPendingMs: number | null;
+};
+/**
+ * Handler for state monitor events.
+ */
+type StateMonitorEventHandler = (event: StateMonitorEvent) => void;
+/**
+ * Options for creating a StateMonitor.
+ */
+interface StateMonitorOptions {
+  /** Handler for monitor events */
+  readonly onEvent?: StateMonitorEventHandler;
+  /** Interval for health checks in ms (default: 5000) */
+  readonly healthCheckInterval?: number;
+  /** Threshold for considering a pending transaction "stale" in ms (default: 10000) */
+  readonly stalePendingThreshold?: number;
+  /** Maximum allowed version gap before triggering recovery (default: 10) */
+  readonly maxVersionGap?: number;
+}
+/**
+ * Pending transaction info for monitoring.
+ */
+interface PendingInfo {
+  readonly id: string;
+  readonly sentAt: number;
+}
+/**
+ * A StateMonitor watches for state drift and triggers recovery.
+ */
+interface StateMonitor {
+  /**
+   * Called when a server transaction is received.
+   * Returns true if the version is valid, false if drift is detected.
+   */
+  readonly onServerVersion: (version: number) => boolean;
+  /**
+   * Called when a pending transaction is added.
+   */
+  readonly trackPending: (info: PendingInfo) => void;
+  /**
+   * Called when a pending transaction is confirmed or rejected.
+   */
+  readonly untrackPending: (id: string) => void;
+  /**
+   * Returns pending transactions that have exceeded the stale threshold.
+   */
+  readonly getStalePending: () => PendingInfo[];
+  /**
+   * Returns current monitoring status.
+   */
+  readonly getStatus: () => StateMonitorStatus;
+  /**
+   * Starts the health check loop.
+   */
+  readonly start: () => void;
+  /**
+   * Stops the health check loop.
+   */
+  readonly stop: () => void;
+  /**
+   * Resets the monitor state (called after recovery).
+   */
+  readonly reset: (newVersion: number) => void;
+}
+/**
+ * Current monitoring status.
+ */
+interface StateMonitorStatus {
+  readonly expectedVersion: number;
+  readonly pendingCount: number;
+  readonly oldestPendingMs: number | null;
+  readonly isHealthy: boolean;
+  readonly isRecovering: boolean;
+}
+/**
+ * Creates a new StateMonitor.
+ */
+declare const make: (options?: StateMonitorOptions) => StateMonitor;
+/**
+ * Recovery actions that can be taken.
+ */
+type RecoveryAction = {
+  type: "request_snapshot";
+} | {
+  type: "retry_pending";
+  transactionIds: string[];
+} | {
+  type: "drop_pending";
+  transactionIds: string[];
+};
+/**
+ * Determines the appropriate recovery action based on current state.
+ */
+declare const determineRecoveryAction: (status: StateMonitorStatus, stalePending: PendingInfo[]) => RecoveryAction;
+//#endregion
+export { StateMonitor_d_exports };
+//# sourceMappingURL=StateMonitor.d.cts.map

package/dist/client/StateMonitor.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMonitor.d.cts","names":[],"sources":["../../src/client/StateMonitor.ts"],"sourcesContent":[],"mappings":";;;;;;KASY,iBAAA;;;;;;;;;;;EAAA,KAAA,EAI0B,KAJ1B;AAWZ,CAAA,GAAY;EAKK,IAAA,EAAA,iBAAmB;EAcnB,aAAA,EAAW,MAAA;EAQX,SAAA,EAAA,MAAY;CAUG,GAAA;EAUE,IAAA,EAAA,cAAA;EAKN,YAAA,EAAA,MAAA;EAAkB,eAAA,EAAA,MAAA,GAAA,IAAA;AAqB9C,CAAA;AAeA;AA2KA;AAQA;AACU,KA5QE,wBAAA,GA4QF,CAAA,KAAA,EA5QqC,iBA4QrC,EAAA,GAAA,IAAA;;;;UAvQO,mBAAA;;qBAEI;;;;;;;;;;;UAYJ,WAAA;;;;;;;UAQA,YAAA;;;;;;;;;gCAUe;;;;;;;;kCAUE;;;;4BAKN;;;;;;;;;;;;;;;;;UAqBX,kBAAA;;;;;;;;;;cAeJ,iBAAiB,wBAA2B;;;;KA2K7C,cAAA;;;;;;;;;;;;cAQC,kCACH,kCACM,kBACb"}

package/dist/client/StateMonitor.d.mts

@@ -0,0 +1,122 @@
+declare namespace StateMonitor_d_exports {
+  export { PendingInfo, RecoveryAction, StateMonitor, StateMonitorEvent, StateMonitorEventHandler, StateMonitorOptions, StateMonitorStatus, determineRecoveryAction, make };
+}
+/**
+ * Events emitted by the state monitor.
+ */
+type StateMonitorEvent = {
+  type: "drift_detected";
+  expectedVersion: number;
+  receivedVersion: number;
+} | {
+  type: "recovery_started";
+} | {
+  type: "recovery_completed";
+  version: number;
+} | {
+  type: "recovery_failed";
+  error: Error;
+} | {
+  type: "pending_timeout";
+  transactionId: string;
+  elapsedMs: number;
+} | {
+  type: "health_check";
+  pendingCount: number;
+  oldestPendingMs: number | null;
+};
+/**
+ * Handler for state monitor events.
+ */
+type StateMonitorEventHandler = (event: StateMonitorEvent) => void;
+/**
+ * Options for creating a StateMonitor.
+ */
+interface StateMonitorOptions {
+  /** Handler for monitor events */
+  readonly onEvent?: StateMonitorEventHandler;
+  /** Interval for health checks in ms (default: 5000) */
+  readonly healthCheckInterval?: number;
+  /** Threshold for considering a pending transaction "stale" in ms (default: 10000) */
+  readonly stalePendingThreshold?: number;
+  /** Maximum allowed version gap before triggering recovery (default: 10) */
+  readonly maxVersionGap?: number;
+}
+/**
+ * Pending transaction info for monitoring.
+ */
+interface PendingInfo {
+  readonly id: string;
+  readonly sentAt: number;
+}
+/**
+ * A StateMonitor watches for state drift and triggers recovery.
+ */
+interface StateMonitor {
+  /**
+   * Called when a server transaction is received.
+   * Returns true if the version is valid, false if drift is detected.
+   */
+  readonly onServerVersion: (version: number) => boolean;
+  /**
+   * Called when a pending transaction is added.
+   */
+  readonly trackPending: (info: PendingInfo) => void;
+  /**
+   * Called when a pending transaction is confirmed or rejected.
+   */
+  readonly untrackPending: (id: string) => void;
+  /**
+   * Returns pending transactions that have exceeded the stale threshold.
+   */
+  readonly getStalePending: () => PendingInfo[];
+  /**
+   * Returns current monitoring status.
+   */
+  readonly getStatus: () => StateMonitorStatus;
+  /**
+   * Starts the health check loop.
+   */
+  readonly start: () => void;
+  /**
+   * Stops the health check loop.
+   */
+  readonly stop: () => void;
+  /**
+   * Resets the monitor state (called after recovery).
+   */
+  readonly reset: (newVersion: number) => void;
+}
+/**
+ * Current monitoring status.
+ */
+interface StateMonitorStatus {
+  readonly expectedVersion: number;
+  readonly pendingCount: number;
+  readonly oldestPendingMs: number | null;
+  readonly isHealthy: boolean;
+  readonly isRecovering: boolean;
+}
+/**
+ * Creates a new StateMonitor.
+ */
+declare const make: (options?: StateMonitorOptions) => StateMonitor;
+/**
+ * Recovery actions that can be taken.
+ */
+type RecoveryAction = {
+  type: "request_snapshot";
+} | {
+  type: "retry_pending";
+  transactionIds: string[];
+} | {
+  type: "drop_pending";
+  transactionIds: string[];
+};
+/**
+ * Determines the appropriate recovery action based on current state.
+ */
+declare const determineRecoveryAction: (status: StateMonitorStatus, stalePending: PendingInfo[]) => RecoveryAction;
+//#endregion
+export { StateMonitor_d_exports };
+//# sourceMappingURL=StateMonitor.d.mts.map

package/dist/client/StateMonitor.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMonitor.d.mts","names":[],"sources":["../../src/client/StateMonitor.ts"],"sourcesContent":[],"mappings":";;;;;;KASY,iBAAA;;;;;;;;;;;EAAA,KAAA,EAI0B,KAJ1B;AAWZ,CAAA,GAAY;EAKK,IAAA,EAAA,iBAAmB;EAcnB,aAAA,EAAW,MAAA;EAQX,SAAA,EAAA,MAAY;CAUG,GAAA;EAUE,IAAA,EAAA,cAAA;EAKN,YAAA,EAAA,MAAA;EAAkB,eAAA,EAAA,MAAA,GAAA,IAAA;AAqB9C,CAAA;AAeA;AA2KA;AAQA;AACU,KA5QE,wBAAA,GA4QF,CAAA,KAAA,EA5QqC,iBA4QrC,EAAA,GAAA,IAAA;;;;UAvQO,mBAAA;;qBAEI;;;;;;;;;;;UAYJ,WAAA;;;;;;;UAQA,YAAA;;;;;;;;;gCAUe;;;;;;;;kCAUE;;;;4BAKN;;;;;;;;;;;;;;;;;UAqBX,kBAAA;;;;;;;;;;cAeJ,iBAAiB,wBAA2B;;;;KA2K7C,cAAA;;;;;;;;;;;;cAQC,kCACH,kCACM,kBACb"}