jettypod 4.4.120 → 4.4.121

package/apps/dashboard/lib/session-state-utils.ts

@@ -57,170 +57,6 @@ export function createSyncRef<T>(initialValue: T): SyncRef<T> {
   };
 }
 
-// ============================================================================
-// Atomic State Updates
-// ============================================================================
-
-/**
- * Result of an atomic update operation.
- */
-export interface AtomicUpdateResult<T> {
-  /** Whether the update was applied */
-  applied: boolean;
-  /** The resulting state (whether updated or not) */
-  state: T;
-  /** If not applied, the reason */
-  reason?: 'version_mismatch' | 'condition_failed' | 'locked';
-}
-
-/**
- * Options for atomic update.
- */
-export interface AtomicUpdateOptions<T> {
-  /** Only apply if this condition returns true */
-  condition?: (currentState: T) => boolean;
-  /** Timeout for acquiring lock (ms). Default: 5000 */
-  timeoutMs?: number;
-}
-
-/**
- * Atomic state container that prevents concurrent update races.
- * Uses optimistic locking with version numbers.
- */
-export class AtomicState<T> {
-  private state: T;
-  private version: number = 0;
-  private locked: boolean = false;
-  private lockQueue: Array<() => void> = [];
-
-  constructor(initialState: T) {
-    this.state = initialState;
-  }
-
-  /**
-   * Get current state and version.
-   */
-  get(): { state: T; version: number } {
-    return { state: this.state, version: this.version };
-  }
-
-  /**
-   * Attempt to update state atomically.
-   * Only succeeds if the version matches (no concurrent updates).
-   *
-   * @param expectedVersion - The version you read before making changes
-   * @param newState - The new state to apply
-   * @param options - Optional conditions and timeout
-   */
-  compareAndSet(
-    expectedVersion: number,
-    newState: T,
-    options?: AtomicUpdateOptions<T>
-  ): AtomicUpdateResult<T> {
-    // Check version
-    if (this.version !== expectedVersion) {
-      return {
-        applied: false,
-        state: this.state,
-        reason: 'version_mismatch',
-      };
-    }
-
-    // Check condition if provided
-    if (options?.condition && !options.condition(this.state)) {
-      return {
-        applied: false,
-        state: this.state,
-        reason: 'condition_failed',
-      };
-    }
-
-    // Apply update
-    this.state = newState;
-    this.version++;
-
-    return {
-      applied: true,
-      state: this.state,
-    };
-  }
-
-  /**
-   * Update state with a transform function, handling retries automatically.
-   * This is the recommended way to update state when you need read-modify-write.
-   *
-   * @param transform - Function that takes current state and returns new state
-   * @param maxRetries - Maximum retries on version conflict. Default: 3
-   */
-  update(transform: (current: T) => T, maxRetries: number = 3): AtomicUpdateResult<T> {
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const { state: current, version } = this.get();
-      const newState = transform(current);
-      const result = this.compareAndSet(version, newState);
-
-      if (result.applied) {
-        return result;
-      }
-
-      // Version mismatch - retry with fresh state
-      if (result.reason !== 'version_mismatch') {
-        return result;
-      }
-    }
-
-    // All retries exhausted
-    return {
-      applied: false,
-      state: this.state,
-      reason: 'version_mismatch',
-    };
-  }
-
-  /**
-   * Acquire exclusive lock for complex multi-step operations.
-   * Use sparingly - prefer compareAndSet or update for simple cases.
-   */
-  async lock(timeoutMs: number = 5000): Promise<() => void> {
-    if (!this.locked) {
-      this.locked = true;
-      return () => this.unlock();
-    }
-
-    // Wait for lock
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        const index = this.lockQueue.indexOf(tryAcquire);
-        if (index >= 0) this.lockQueue.splice(index, 1);
-        reject(new Error('Lock acquisition timeout'));
-      }, timeoutMs);
-
-      const tryAcquire = () => {
-        clearTimeout(timeout);
-        this.locked = true;
-        resolve(() => this.unlock());
-      };
-
-      this.lockQueue.push(tryAcquire);
-    });
-  }
-
-  private unlock(): void {
-    if (this.lockQueue.length > 0) {
-      const next = this.lockQueue.shift();
-      next?.();
-    } else {
-      this.locked = false;
-    }
-  }
-
-  /**
-   * Get current version (for debugging/monitoring).
-   */
-  getVersion(): number {
-    return this.version;
-  }
-}
-
 // ============================================================================
 // Session-Specific Helpers
 // ============================================================================