@voidhash/mimic 0.0.1 → 0.0.3

package/dist/client/ClientDocument.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientDocument.mjs","names":["_serverState: Primitive.InferState<TSchema> | undefined","_pending: PendingTransaction[]","_serverTransactionHistory: Transaction.Transaction[]","Document.make","_unsubscribe: (() => void) | null","_initState: InitState","_initTimeoutHandle: ReturnType<typeof setTimeout> | null","_initResolver: (() => void) | null","_initRejecter: ((error: Error) => void) | null","_presenceSelfId: string | undefined","_presenceSelfData: unknown","pending: PendingTransaction","Rebase.transformTransactionWithPrimitive","Rebase.rebaseAfterRejectionWithPrimitive","Transaction.isEmpty","Presence.validate"],"sources":["../../src/client/ClientDocument.ts"],"sourcesContent":["import * as Document from \"../Document\";\nimport * as Transaction from \"../Transaction\";\nimport * as Presence from \"../Presence\";\nimport type * as Primitive from \"../Primitive\";\nimport type * as Transport from \"./Transport\";\nimport * as Rebase from \"./Rebase\";\nimport {\n  TransactionRejectedError,\n  NotConnectedError,\n  InvalidStateError,\n} from \"./errors\";\n\n// =============================================================================\n// Client Document Types\n// =============================================================================\n\n/**\n * Pending transaction with metadata for tracking.\n */\ninterface PendingTransaction {\n  /** The transaction */\n  readonly transaction: Transaction.Transaction;\n  /** Original transaction before any rebasing */\n  readonly original: Transaction.Transaction;\n  /** Timestamp when the transaction was sent */\n  readonly sentAt: number;\n}\n\n/**\n * Initialization state for the client document.\n * Handles the race condition during startup where transactions\n * may arrive while fetching the initial snapshot.\n */\ntype InitState =\n  | { readonly type: \"uninitialized\" }\n  | { readonly type: \"initializing\"; readonly bufferedMessages: Transport.ServerMessage[] }\n  | { readonly type: \"ready\" };\n\n// =============================================================================\n// Presence Types\n// =============================================================================\n\n/**\n * Listener for presence changes.\n */\nexport interface PresenceListener<_TData> {\n  /** Called when any presence changes (self or others) */\n  readonly onPresenceChange?: () => void;\n}\n\n/**\n * Presence API exposed on the ClientDocument.\n */\nexport interface ClientPresence<TData> {\n  /**\n   * Returns this client's connection ID (set after receiving presence_snapshot).\n   * Returns undefined before the snapshot is received.\n   */\n  readonly selfId: () => string | undefined;\n\n  /**\n   * Returns this client's current presence data.\n   * Returns undefined if not set.\n   */\n  readonly self: () => TData | undefined;\n\n  /**\n   * Returns a map of other clients' presence data.\n   * Keys are connection IDs.\n   */\n  readonly others: () => ReadonlyMap<string, Presence.PresenceEntry<TData>>;\n\n  /**\n   * Returns all presence entries including self.\n   */\n  readonly all: () => ReadonlyMap<string, Presence.PresenceEntry<TData>>;\n\n  /**\n   * Sets this client's presence data.\n   * Validates against the presence schema before sending.\n   * @throws ParseError if validation fails\n   */\n  readonly set: (data: TData) => void;\n\n  /**\n   * Clears this client's presence data.\n   */\n  readonly clear: () => void;\n\n  /**\n   * Subscribes to presence changes.\n   * @returns Unsubscribe function\n   */\n  readonly subscribe: (listener: PresenceListener<TData>) => () => void;\n}\n\n/**\n * Options for creating a ClientDocument.\n */\nexport interface ClientDocumentOptions<\n  TSchema extends Primitive.AnyPrimitive,\n  TPresence extends Presence.AnyPresence | undefined = undefined\n> {\n  /** The schema defining the document structure */\n  readonly schema: TSchema;\n  /** Transport for server communication */\n  readonly transport: Transport.Transport;\n  /** Initial state (optional, will sync from server if not provided) */\n  readonly initialState?: Primitive.InferState<TSchema>;\n  /** Initial server version (optional) */\n  readonly initialVersion?: number;\n  /** Called when server rejects a transaction */\n  readonly onRejection?: (\n    transaction: Transaction.Transaction,\n    reason: string\n  ) => void;\n  /** Called when optimistic state changes */\n  readonly onStateChange?: (state: Primitive.InferState<TSchema> | undefined) => void;\n  /** Called when connection status changes */\n  readonly onConnectionChange?: (connected: boolean) => void;\n  /** Called when client is fully initialized and ready */\n  readonly onReady?: () => void;\n  /** Timeout in ms for pending transactions (default: 30000) */\n  readonly transactionTimeout?: number;\n  /** Timeout in ms for initialization (default: 10000) */\n  readonly initTimeout?: number;\n  /** Enable debug logging for all activity (default: false) */\n  readonly debug?: boolean;\n  /**\n   * Optional presence schema for ephemeral per-user data.\n   * When provided, enables the presence API on the ClientDocument.\n   */\n  readonly presence?: TPresence;\n  /** Initial presence data, that will be set on the ClientDocument when it is created */\n  readonly initialPresence?: TPresence extends Presence.AnyPresence ? Presence.Infer<TPresence> : undefined;\n}\n\n/**\n * Listener callbacks for subscribing to ClientDocument events.\n */\nexport interface ClientDocumentListener<TSchema extends Primitive.AnyPrimitive> {\n  /** Called when optimistic state changes */\n  readonly onStateChange?: (state: Primitive.InferState<TSchema> | undefined) => void;\n  /** Called when connection status changes */\n  readonly onConnectionChange?: (connected: boolean) => void;\n  /** Called when client is fully initialized and ready */\n  readonly onReady?: () => void;\n}\n\n/**\n * A ClientDocument provides optimistic updates with server synchronization.\n */\nexport interface ClientDocument<\n  TSchema extends Primitive.AnyPrimitive,\n  TPresence extends Presence.AnyPresence | undefined = undefined\n> {\n  /** The schema defining this document's structure */\n  readonly schema: TSchema;\n\n  /** Root proxy for accessing and modifying document data (optimistic) */\n  readonly root: Primitive.InferProxy<TSchema>;\n\n  /** Returns the current optimistic state (server + pending) */\n  get(): Primitive.InferState<TSchema> | undefined;\n\n  /** Returns the confirmed server state */\n  getServerState(): Primitive.InferState<TSchema> | undefined;\n\n  /** Returns the current server version */\n  getServerVersion(): number;\n\n  /** Returns pending transactions count */\n  getPendingCount(): number;\n\n  /** Returns whether there are pending transactions */\n  hasPendingChanges(): boolean;\n\n  /**\n   * Runs a function within a transaction.\n   * Changes are applied optimistically and sent to the server.\n   */\n  transaction<R>(fn: (root: Primitive.InferProxy<TSchema>) => R): R;\n\n  /**\n   * Connects to the server and starts syncing.\n   */\n  connect(): Promise<void>;\n\n  /**\n   * Disconnects from the server.\n   */\n  disconnect(): void;\n\n  /**\n   * Returns whether currently connected to the server.\n   */\n  isConnected(): boolean;\n\n  /**\n   * Forces a full resync from the server.\n   */\n  resync(): void;\n\n  /**\n   * Returns whether the client is fully initialized and ready.\n   */\n  isReady(): boolean;\n\n  /**\n   * Subscribes to document events (state changes, connection changes, ready).\n   * @returns Unsubscribe function\n   */\n  subscribe(listener: ClientDocumentListener<TSchema>): () => void;\n\n  /**\n   * Presence API for ephemeral per-user data.\n   * Only available when presence schema is provided in options.\n   */\n  readonly presence: TPresence extends Presence.AnyPresence\n    ? ClientPresence<Presence.Infer<TPresence>>\n    : undefined;\n}\n\n// =============================================================================\n// Client Document Implementation\n// =============================================================================\n\n/**\n * Creates a new ClientDocument for the given schema.\n */\nexport const make = <\n  TSchema extends Primitive.AnyPrimitive,\n  TPresence extends Presence.AnyPresence | undefined = undefined\n>(\n  options: ClientDocumentOptions<TSchema, TPresence>\n): ClientDocument<TSchema, TPresence> => {\n  const {\n    schema,\n    transport,\n    initialState,\n    initialVersion = 0,\n    onRejection,\n    onStateChange,\n    onConnectionChange,\n    onReady,\n    transactionTimeout = 30000,\n    initTimeout = 10000,\n    debug = false,\n    presence: presenceSchema,\n    initialPresence,\n  } = options;\n\n  // ==========================================================================\n  // Internal State\n  // ==========================================================================\n\n  // Server-confirmed state\n  let _serverState: Primitive.InferState<TSchema> | undefined = initialState;\n  let _serverVersion = initialVersion;\n\n  // Pending transactions queue\n  let _pending: PendingTransaction[] = [];\n\n  // Server transactions received (for rebase after rejection)\n  let _serverTransactionHistory: Transaction.Transaction[] = [];\n  const MAX_HISTORY_SIZE = 100;\n\n  // The underlying document for optimistic state\n  let _optimisticDoc = Document.make(schema, { initial: _serverState });\n\n  // Subscription cleanup\n  let _unsubscribe: (() => void) | null = null;\n\n  // Timeout handles for pending transactions\n  const _timeoutHandles = new Map<string, ReturnType<typeof setTimeout>>();\n\n  // Initialization state - handles buffering during startup\n  let _initState: InitState = initialState !== undefined\n    ? { type: \"ready\" }\n    : { type: \"uninitialized\" };\n\n  // Init timeout handle\n  let _initTimeoutHandle: ReturnType<typeof setTimeout> | null = null;\n\n  // Promise resolver for connect() to wait for ready state\n  let _initResolver: (() => void) | null = null;\n  let _initRejecter: ((error: Error) => void) | null = null;\n\n  // Subscribers for events (added after creation via subscribe())\n  const _subscribers = new Set<ClientDocumentListener<TSchema>>();\n\n  // ==========================================================================\n  // Presence State (only used when presenceSchema is provided)\n  // ==========================================================================\n\n  // This client's connection ID (received from presence_snapshot)\n  let _presenceSelfId: string | undefined = undefined;\n\n  // This client's current presence data\n  let _presenceSelfData: unknown = undefined;\n\n  // Other clients' presence entries (connectionId -> entry)\n  const _presenceOthers = new Map<string, Presence.PresenceEntry<unknown>>();\n\n  // Presence change subscribers\n  const _presenceSubscribers = new Set<PresenceListener<unknown>>();\n\n  // ==========================================================================\n  // Debug Logging\n  // ==========================================================================\n\n  /**\n   * Debug logging helper that only logs when debug is enabled.\n   */\n  const debugLog = (...args: unknown[]): void => {\n    if (debug) {\n      console.log(\"[ClientDocument]\", ...args);\n    }\n  };\n\n  // ==========================================================================\n  // Notification Helpers\n  // ==========================================================================\n\n  /**\n   * Notifies all listeners of a state change.\n   */\n  const notifyStateChange = (state: Primitive.InferState<TSchema> | undefined): void => {\n    debugLog(\"notifyStateChange\", {\n      state,\n      subscriberCount: _subscribers.size,\n      hasOnStateChange: !!onStateChange,\n    });\n    onStateChange?.(state);\n    for (const listener of _subscribers) {\n      listener.onStateChange?.(state);\n    }\n  };\n\n  /**\n   * Notifies all listeners of a connection change.\n   */\n  const notifyConnectionChange = (connected: boolean): void => {\n    debugLog(\"notifyConnectionChange\", {\n      connected,\n      subscriberCount: _subscribers.size,\n      hasOnConnectionChange: !!onConnectionChange,\n    });\n    onConnectionChange?.(connected);\n    for (const listener of _subscribers) {\n      listener.onConnectionChange?.(connected);\n    }\n  };\n\n  /**\n   * Notifies all listeners when ready.\n   */\n  const notifyReady = (): void => {\n    debugLog(\"notifyReady\", {\n      subscriberCount: _subscribers.size,\n      hasOnReady: !!onReady,\n    });\n    onReady?.();\n    for (const listener of _subscribers) {\n      listener.onReady?.();\n    }\n  };\n\n  /**\n   * Notifies all presence listeners of a change.\n   */\n  const notifyPresenceChange = (): void => {\n    debugLog(\"notifyPresenceChange\", {\n      subscriberCount: _presenceSubscribers.size,\n    });\n    for (const listener of _presenceSubscribers) {\n      try {\n        listener.onPresenceChange?.();\n      } catch {\n        // Ignore listener errors\n      }\n    }\n  };\n\n  // ==========================================================================\n  // Presence Handlers\n  // ==========================================================================\n\n  /**\n   * Handles incoming presence snapshot from server.\n   */\n  const handlePresenceSnapshot = (message: Transport.PresenceSnapshotMessage): void => {\n    if (!presenceSchema) return;\n\n    debugLog(\"handlePresenceSnapshot\", {\n      selfId: message.selfId,\n      presenceCount: Object.keys(message.presences).length,\n    });\n\n    _presenceSelfId = message.selfId;\n    _presenceOthers.clear();\n\n    // Populate others from snapshot (exclude self)\n    for (const [id, entry] of Object.entries(message.presences)) {\n      if (id !== message.selfId) {\n        _presenceOthers.set(id, entry);\n      }\n    }\n\n    notifyPresenceChange();\n  };\n\n  /**\n   * Handles incoming presence update from server (another user).\n   */\n  const handlePresenceUpdate = (message: Transport.PresenceUpdateMessage): void => {\n    if (!presenceSchema) return;\n\n    debugLog(\"handlePresenceUpdate\", {\n      id: message.id,\n      userId: message.userId,\n    });\n\n    _presenceOthers.set(message.id, {\n      data: message.data,\n      userId: message.userId,\n    });\n\n    notifyPresenceChange();\n  };\n\n  /**\n   * Handles incoming presence remove from server (user disconnected).\n   */\n  const handlePresenceRemove = (message: Transport.PresenceRemoveMessage): void => {\n    if (!presenceSchema) return;\n\n    debugLog(\"handlePresenceRemove\", {\n      id: message.id,\n    });\n\n    _presenceOthers.delete(message.id);\n    notifyPresenceChange();\n  };\n\n  /**\n   * Clears all presence state (on disconnect).\n   */\n  const clearPresenceState = (): void => {\n    _presenceSelfId = undefined;\n    _presenceSelfData = undefined;\n    _presenceOthers.clear();\n    notifyPresenceChange();\n  };\n\n  // ==========================================================================\n  // Helper Functions\n  // ==========================================================================\n\n  /**\n   * Recomputes the optimistic document from server state + pending transactions.\n   */\n  const recomputeOptimisticState = (): void => {\n    debugLog(\"recomputeOptimisticState\", {\n      serverVersion: _serverVersion,\n      pendingCount: _pending.length,\n      serverState: _serverState,\n    });\n\n    // Create fresh document from server state\n    _optimisticDoc = Document.make(schema, { initial: _serverState });\n\n    // Apply all pending transactions\n    for (const pending of _pending) {\n      _optimisticDoc.apply(pending.transaction.ops);\n    }\n\n    const newState = _optimisticDoc.get();\n    debugLog(\"recomputeOptimisticState: new optimistic state\", newState);\n\n    // Notify state change\n    notifyStateChange(newState);\n  };\n\n  /**\n   * Adds a transaction to pending queue and sends to server.\n   */\n  const submitTransaction = (tx: Transaction.Transaction): void => {\n    if (!transport.isConnected()) {\n      throw new NotConnectedError();\n    }\n\n    debugLog(\"submitTransaction\", {\n      txId: tx.id,\n      ops: tx.ops,\n      pendingCount: _pending.length + 1,\n    });\n\n    const pending: PendingTransaction = {\n      transaction: tx,\n      original: tx,\n      sentAt: Date.now(),\n    };\n\n    _pending.push(pending);\n\n    // Set timeout for this transaction\n    const timeoutHandle = setTimeout(() => {\n      handleTransactionTimeout(tx.id);\n    }, transactionTimeout);\n    _timeoutHandles.set(tx.id, timeoutHandle);\n\n    // Send to server\n    transport.send(tx);\n    debugLog(\"submitTransaction: sent to server\", { txId: tx.id });\n  };\n\n  /**\n   * Handles a transaction timeout.\n   */\n  const handleTransactionTimeout = (txId: string): void => {\n    debugLog(\"handleTransactionTimeout\", { txId });\n    const index = _pending.findIndex((p) => p.transaction.id === txId);\n    if (index === -1) {\n      debugLog(\"handleTransactionTimeout: transaction not found (already confirmed/rejected)\", { txId });\n      return; // Already confirmed or rejected\n    }\n\n    // Remove from pending\n    const [removed] = _pending.splice(index, 1);\n    _timeoutHandles.delete(txId);\n\n    debugLog(\"handleTransactionTimeout: removed from pending\", {\n      txId,\n      remainingPending: _pending.length,\n    });\n\n    // Recompute state\n    recomputeOptimisticState();\n\n    // Notify as rejection\n    onRejection?.(removed!.transaction, \"Transaction timed out\");\n  };\n\n  /**\n   * Handles an incoming server transaction.\n   */\n  const handleServerTransaction = (\n    serverTx: Transaction.Transaction,\n    version: number\n  ): void => {\n    debugLog(\"handleServerTransaction\", {\n      txId: serverTx.id,\n      version,\n      ops: serverTx.ops,\n      currentServerVersion: _serverVersion,\n      pendingCount: _pending.length,\n    });\n\n    // Update server version\n    _serverVersion = version;\n\n    // Check if this is one of our pending transactions (ACK)\n    const pendingIndex = _pending.findIndex(\n      (p) => p.transaction.id === serverTx.id\n    );\n\n    if (pendingIndex !== -1) {\n      // This is our transaction - confirmed!\n      debugLog(\"handleServerTransaction: transaction confirmed (ACK)\", {\n        txId: serverTx.id,\n        pendingIndex,\n      });\n\n      const confirmed = _pending[pendingIndex]!;\n\n      // Clear timeout\n      const timeoutHandle = _timeoutHandles.get(serverTx.id);\n      if (timeoutHandle) {\n        clearTimeout(timeoutHandle);\n        _timeoutHandles.delete(serverTx.id);\n      }\n\n      // Remove from pending\n      _pending.splice(pendingIndex, 1);\n\n      // Apply to server state\n      const tempDoc = Document.make(schema, { initial: _serverState });\n      tempDoc.apply(serverTx.ops);\n      _serverState = tempDoc.get();\n\n      debugLog(\"handleServerTransaction: updated server state\", {\n        txId: serverTx.id,\n        newServerState: _serverState,\n        remainingPending: _pending.length,\n      });\n\n      // Recompute optimistic state (pending txs already applied, just need to update base)\n      recomputeOptimisticState();\n    } else {\n      // This is someone else's transaction - need to rebase\n      debugLog(\"handleServerTransaction: remote transaction, rebasing pending\", {\n        txId: serverTx.id,\n        pendingCount: _pending.length,\n      });\n\n      // Apply to server state\n      const tempDoc = Document.make(schema, { initial: _serverState });\n      tempDoc.apply(serverTx.ops);\n      _serverState = tempDoc.get();\n\n      // Add to history for potential rebase after rejection\n      _serverTransactionHistory.push(serverTx);\n      if (_serverTransactionHistory.length > MAX_HISTORY_SIZE) {\n        _serverTransactionHistory.shift();\n      }\n\n      // Rebase all pending transactions using primitive-based transformation\n      const rebasedPending = _pending.map((p) => ({\n        ...p,\n        transaction: Rebase.transformTransactionWithPrimitive(p.transaction, serverTx, schema),\n      }));\n\n      debugLog(\"handleServerTransaction: rebased pending transactions\", {\n        txId: serverTx.id,\n        rebasedCount: rebasedPending.length,\n        originalPendingIds: _pending.map((p) => p.transaction.id),\n        rebasedPendingIds: rebasedPending.map((p) => p.transaction.id),\n      });\n\n      _pending = rebasedPending;\n\n      // Recompute optimistic state\n      recomputeOptimisticState();\n    }\n  };\n\n  /**\n   * Handles a transaction rejection from the server.\n   */\n  const handleRejection = (txId: string, reason: string): void => {\n    debugLog(\"handleRejection\", {\n      txId,\n      reason,\n      pendingCount: _pending.length,\n    });\n\n    const index = _pending.findIndex((p) => p.transaction.id === txId);\n    if (index === -1) {\n      debugLog(\"handleRejection: transaction not found (already removed)\", { txId });\n      return; // Already removed\n    }\n\n    const rejected = _pending[index]!;\n\n    // Clear timeout\n    const timeoutHandle = _timeoutHandles.get(txId);\n    if (timeoutHandle) {\n      clearTimeout(timeoutHandle);\n      _timeoutHandles.delete(txId);\n    }\n\n    // Remove rejected transaction\n    _pending.splice(index, 1);\n\n    debugLog(\"handleRejection: removed rejected transaction, rebasing remaining\", {\n      txId,\n      remainingPending: _pending.length,\n      serverHistorySize: _serverTransactionHistory.length,\n    });\n\n    // Re-transform remaining pending transactions without the rejected one\n    // We need to replay from their original state\n    const remainingOriginals = _pending.map((p) => p.original);\n    const retransformed = Rebase.rebaseAfterRejectionWithPrimitive(\n      [...remainingOriginals, rejected.original],\n      txId,\n      _serverTransactionHistory,\n      schema\n    );\n\n    // Update pending with retransformed versions\n    _pending = _pending.map((p, i) => ({\n      ...p,\n      transaction: retransformed[i] ?? p.transaction,\n    }));\n\n    debugLog(\"handleRejection: rebased remaining transactions\", {\n      txId,\n      rebasedCount: _pending.length,\n    });\n\n    // Recompute optimistic state\n    recomputeOptimisticState();\n\n    // Notify rejection\n    onRejection?.(rejected.original, reason);\n  };\n\n  /**\n   * Handles a snapshot from the server.\n   * @param isInitialSnapshot - If true, this is the initial sync snapshot\n   */\n  const handleSnapshot = (state: unknown, version: number, isInitialSnapshot: boolean = false): void => {\n    debugLog(\"handleSnapshot\", {\n      isInitialSnapshot,\n      version,\n      currentServerVersion: _serverVersion,\n      pendingCount: _pending.length,\n      state,\n    });\n\n    if (!isInitialSnapshot) {\n      debugLog(\"handleSnapshot: non-initial snapshot, clearing pending transactions\", {\n        clearedPendingCount: _pending.length,\n      });\n\n      // For non-initial snapshots, clear all pending (they're now invalid)\n      for (const handle of _timeoutHandles.values()) {\n        clearTimeout(handle);\n      }\n      _timeoutHandles.clear();\n\n      // Notify rejections for all pending\n      for (const pending of _pending) {\n        onRejection?.(pending.original, \"State reset due to resync\");\n      }\n\n      _pending = [];\n    }\n\n    _serverTransactionHistory = [];\n    _serverState = state as Primitive.InferState<TSchema>;\n    _serverVersion = version;\n\n    debugLog(\"handleSnapshot: updated server state\", {\n      newVersion: _serverVersion,\n      newState: _serverState,\n    });\n\n    // Recompute optimistic state (now equals server state)\n    recomputeOptimisticState();\n  };\n\n  /**\n   * Processes buffered messages after receiving the initial snapshot.\n   * Filters out transactions already included in the snapshot (version <= snapshotVersion)\n   * and applies newer transactions in order.\n   */\n  const processBufferedMessages = (\n    bufferedMessages: Transport.ServerMessage[],\n    snapshotVersion: number\n  ): void => {\n    debugLog(\"processBufferedMessages\", {\n      bufferedCount: bufferedMessages.length,\n      snapshotVersion,\n    });\n\n    // Sort transactions by version to ensure correct order\n    const sortedMessages = [...bufferedMessages].sort((a, b) => {\n      if (a.type === \"transaction\" && b.type === \"transaction\") {\n        return a.version - b.version;\n      }\n      return 0;\n    });\n\n    // Process each buffered message\n    for (const message of sortedMessages) {\n      switch (message.type) {\n        case \"transaction\":\n          // Only apply transactions with version > snapshot version\n          if (message.version > snapshotVersion) {\n            debugLog(\"processBufferedMessages: applying buffered transaction\", {\n              txId: message.transaction.id,\n              version: message.version,\n              snapshotVersion,\n            });\n            handleServerTransaction(message.transaction, message.version);\n          } else {\n            debugLog(\"processBufferedMessages: skipping buffered transaction (already in snapshot)\", {\n              txId: message.transaction.id,\n              version: message.version,\n              snapshotVersion,\n            });\n          }\n          break;\n        case \"error\":\n          // Errors are still relevant - pass through\n          debugLog(\"processBufferedMessages: processing buffered error\", {\n            txId: message.transactionId,\n            reason: message.reason,\n          });\n          handleRejection(message.transactionId, message.reason);\n          break;\n        // Ignore additional snapshots in buffer - we already have one\n      }\n    }\n  };\n\n  /**\n   * Completes initialization and transitions to ready state.\n   */\n  const completeInitialization = (): void => {\n    debugLog(\"completeInitialization\");\n\n    // Clear init timeout\n    if (_initTimeoutHandle !== null) {\n      clearTimeout(_initTimeoutHandle);\n      _initTimeoutHandle = null;\n    }\n\n    _initState = { type: \"ready\" };\n\n    // Resolve the connect promise\n    if (_initResolver) {\n      _initResolver();\n      _initResolver = null;\n      _initRejecter = null;\n    }\n\n    debugLog(\"completeInitialization: ready\", {\n      serverVersion: _serverVersion,\n      serverState: _serverState,\n    });\n\n    // Notify ready\n    notifyReady();\n  };\n\n  /**\n   * Handles initialization timeout.\n   */\n  const handleInitTimeout = (): void => {\n    debugLog(\"handleInitTimeout: initialization timed out\");\n    _initTimeoutHandle = null;\n\n    // Reject the connect promise\n    if (_initRejecter) {\n      const error = new Error(\"Initialization timed out waiting for snapshot\");\n      _initRejecter(error);\n      _initResolver = null;\n      _initRejecter = null;\n    }\n\n    // Reset to uninitialized state\n    _initState = { type: \"uninitialized\" };\n  };\n\n  /**\n   * Handles incoming server messages.\n   * During initialization, messages are buffered until the snapshot arrives.\n   * Presence messages are always processed immediately (not buffered).\n   */\n  const handleServerMessage = (message: Transport.ServerMessage): void => {\n    debugLog(\"handleServerMessage\", {\n      messageType: message.type,\n      initState: _initState.type,\n    });\n\n    // Presence messages are always handled immediately (not buffered)\n    // This allows presence to work even during document initialization\n    if (message.type === \"presence_snapshot\") {\n      handlePresenceSnapshot(message);\n      return;\n    }\n    if (message.type === \"presence_update\") {\n      handlePresenceUpdate(message);\n      return;\n    }\n    if (message.type === \"presence_remove\") {\n      handlePresenceRemove(message);\n      return;\n    }\n\n    // Handle based on initialization state\n    if (_initState.type === \"initializing\") {\n      if (message.type === \"snapshot\") {\n        debugLog(\"handleServerMessage: received snapshot during initialization\", {\n          version: message.version,\n          bufferedCount: _initState.bufferedMessages.length,\n        });\n        // Snapshot received - apply it and process buffered messages\n        const buffered = _initState.bufferedMessages;\n        handleSnapshot(message.state, message.version, true);\n        processBufferedMessages(buffered, message.version);\n        completeInitialization();\n      } else {\n        debugLog(\"handleServerMessage: buffering message during initialization\", {\n          messageType: message.type,\n          bufferedCount: _initState.bufferedMessages.length + 1,\n        });\n        // Buffer other messages during initialization\n        _initState.bufferedMessages.push(message);\n      }\n      return;\n    }\n\n    // Normal message handling when ready (or uninitialized with initial state)\n    switch (message.type) {\n      case \"transaction\":\n        handleServerTransaction(message.transaction, message.version);\n        break;\n      case \"snapshot\":\n        handleSnapshot(message.state, message.version, false);\n        break;\n      case \"error\":\n        handleRejection(message.transactionId, message.reason);\n        break;\n    }\n  };\n\n  // ==========================================================================\n  // Public API\n  // ==========================================================================\n\n  const clientDocument = {\n    schema,\n\n    get root() {\n      return _optimisticDoc.root;\n    },\n\n    get: () => _optimisticDoc.get(),\n\n    getServerState: () => _serverState,\n\n    getServerVersion: () => _serverVersion,\n\n    getPendingCount: () => _pending.length,\n\n    hasPendingChanges: () => _pending.length > 0,\n\n    transaction: <R,>(fn: (root: Primitive.InferProxy<TSchema>) => R): R => {\n      debugLog(\"transaction: starting\", {\n        isConnected: transport.isConnected(),\n        isReady: _initState.type === \"ready\",\n        pendingCount: _pending.length,\n      });\n\n      if (!transport.isConnected()) {\n        throw new NotConnectedError();\n      }\n\n      if (_initState.type !== \"ready\") {\n        throw new InvalidStateError(\"Client is not ready. Wait for initialization to complete.\");\n      }\n\n      // Run the transaction on the optimistic document\n      const result = _optimisticDoc.transaction(fn);\n\n      // Flush and get the transaction\n      const tx = _optimisticDoc.flush();\n\n      // If there are operations, submit to server\n      if (!Transaction.isEmpty(tx)) {\n        debugLog(\"transaction: flushed, submitting\", {\n          txId: tx.id,\n          opsCount: tx.ops.length,\n        });\n        submitTransaction(tx);\n      } else {\n        debugLog(\"transaction: flushed, empty transaction (no ops)\");\n      }\n\n      // Notify state change\n      notifyStateChange(_optimisticDoc.get());\n\n      return result;\n    },\n\n    connect: async (): Promise<void> => {\n      debugLog(\"connect: starting\");\n      // Subscribe to server messages\n      _unsubscribe = transport.subscribe(handleServerMessage);\n\n      // Connect transport\n      await transport.connect();\n      debugLog(\"connect: transport connected\");\n\n      notifyConnectionChange(true);\n\n      // Set initial presence if provided\n      if (presenceSchema && initialPresence !== undefined) {\n        debugLog(\"connect: setting initial presence\", { initialPresence });\n        const validated = Presence.validate(presenceSchema, initialPresence);\n        _presenceSelfData = validated;\n        transport.sendPresenceSet(validated);\n        notifyPresenceChange();\n      }\n\n      // If we already have initial state, we're ready immediately\n      if (_initState.type === \"ready\") {\n        debugLog(\"connect: already ready (has initial state)\");\n        notifyReady();\n        return;\n      }\n\n      // Enter initializing state - buffer messages until snapshot arrives\n      _initState = { type: \"initializing\", bufferedMessages: [] };\n      debugLog(\"connect: entering initializing state\", {\n        initTimeout,\n      });\n\n      // Set up initialization timeout\n      _initTimeoutHandle = setTimeout(handleInitTimeout, initTimeout);\n\n      // Create a promise that resolves when we're ready\n      const readyPromise = new Promise<void>((resolve, reject) => {\n        _initResolver = resolve;\n        _initRejecter = reject;\n      });\n\n      // Request initial snapshot\n      debugLog(\"connect: requesting initial snapshot\");\n   \n      transport.requestSnapshot();\n\n\n      // Wait for initialization to complete\n      await readyPromise;\n      debugLog(\"connect: completed\");\n    },\n\n    disconnect: (): void => {\n      debugLog(\"disconnect: starting\", {\n        pendingCount: _pending.length,\n        initState: _initState.type,\n      });\n\n      // Clear all timeouts\n      for (const handle of _timeoutHandles.values()) {\n        clearTimeout(handle);\n      }\n      _timeoutHandles.clear();\n\n      // Clear init timeout\n      if (_initTimeoutHandle !== null) {\n        clearTimeout(_initTimeoutHandle);\n        _initTimeoutHandle = null;\n      }\n\n      // Reject any pending init promise\n      if (_initRejecter) {\n        _initRejecter(new Error(\"Disconnected during initialization\"));\n        _initResolver = null;\n        _initRejecter = null;\n      }\n\n      // Reset init state\n      if (_initState.type === \"initializing\") {\n        _initState = { type: \"uninitialized\" };\n      }\n\n      // Clear presence state\n      clearPresenceState();\n\n      // Unsubscribe\n      if (_unsubscribe) {\n        _unsubscribe();\n        _unsubscribe = null;\n      }\n\n      // Disconnect transport\n      transport.disconnect();\n\n      notifyConnectionChange(false);\n      debugLog(\"disconnect: completed\");\n    },\n\n    isConnected: () => transport.isConnected(),\n\n    isReady: () => _initState.type === \"ready\",\n\n    resync: (): void => {\n      debugLog(\"resync: requesting snapshot\", {\n        currentVersion: _serverVersion,\n        pendingCount: _pending.length,\n      });\n      if (!transport.isConnected()) {\n        throw new NotConnectedError();\n      }\n      transport.requestSnapshot();\n    },\n\n    subscribe: (listener: ClientDocumentListener<TSchema>): (() => void) => {\n      _subscribers.add(listener);\n      return () => {\n        _subscribers.delete(listener);\n      };\n    },\n\n    // =========================================================================\n    // Presence API\n    // =========================================================================\n\n    presence: (presenceSchema\n      ? {\n          selfId: () => _presenceSelfId,\n\n          self: () => _presenceSelfData as Presence.Infer<NonNullable<TPresence>> | undefined,\n\n          others: () => _presenceOthers as ReadonlyMap<string, Presence.PresenceEntry<Presence.Infer<NonNullable<TPresence>>>>,\n\n          all: () => {\n            const all = new Map<string, Presence.PresenceEntry<unknown>>();\n            // Add others\n            for (const [id, entry] of _presenceOthers) {\n              all.set(id, entry);\n            }\n            // Add self if we have data\n            if (_presenceSelfId !== undefined && _presenceSelfData !== undefined) {\n              all.set(_presenceSelfId, { data: _presenceSelfData });\n            }\n            return all as ReadonlyMap<string, Presence.PresenceEntry<Presence.Infer<NonNullable<TPresence>>>>;\n          },\n\n          set: (data: Presence.Infer<NonNullable<TPresence>>) => {\n            if (!presenceSchema) return;\n\n            // Validate against schema (throws if invalid)\n            const validated = Presence.validate(presenceSchema, data);\n\n            debugLog(\"presence.set\", { data: validated });\n\n            // Update local state\n            _presenceSelfData = validated;\n\n            // Send to server\n            transport.sendPresenceSet(validated);\n\n            // Notify listeners\n            notifyPresenceChange();\n          },\n\n          clear: () => {\n            if (!presenceSchema) return;\n\n            debugLog(\"presence.clear\");\n\n            // Clear local state\n            _presenceSelfData = undefined;\n\n            // Send to server\n            transport.sendPresenceClear();\n\n            // Notify listeners\n            notifyPresenceChange();\n          },\n\n          subscribe: (listener: PresenceListener<Presence.Infer<NonNullable<TPresence>>>) => {\n            _presenceSubscribers.add(listener as PresenceListener<unknown>);\n            return () => {\n              _presenceSubscribers.delete(listener as PresenceListener<unknown>);\n            };\n          },\n        }\n      : undefined) as TPresence extends Presence.AnyPresence\n      ? ClientPresence<Presence.Infer<TPresence>>\n      : undefined,\n  } as ClientDocument<TSchema, TPresence>;\n\n  return clientDocument;\n};\n"],"mappings":"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"}

package/dist/client/Rebase.cjs

@@ -0,0 +1,204 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_OperationPath = require('../OperationPath.cjs');
+
+//#region src/client/Rebase.ts
+var Rebase_exports = /* @__PURE__ */ require_rolldown_runtime.__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 (!require_OperationPath.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 (require_OperationPath.pathsEqual(clientPath, serverPath)) return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (require_OperationPath.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
+Object.defineProperty(exports, 'Rebase_exports', {
+  enumerable: true,
+  get: function () {
+    return Rebase_exports;
+  }
+});
+exports.rebaseAfterRejectionWithPrimitive = rebaseAfterRejectionWithPrimitive;
+exports.transformTransactionWithPrimitive = transformTransactionWithPrimitive;

package/dist/client/Rebase.d.cts

@@ -0,0 +1,87 @@
+import { Operation } from "../Operation.cjs";
+import { Transaction } from "../Transaction.cjs";
+import { TransformResult as TransformResult$1 } from "../Transform.cjs";
+import { AnyPrimitive } from "../primitives/shared.cjs";
+
+//#region src/client/Rebase.d.ts
+declare namespace Rebase_d_exports {
+  export { TransformResult, rebaseAfterRejection, rebaseAfterRejectionWithPrimitive, rebasePendingTransactions, rebasePendingTransactionsWithPrimitive, transformOperation, transformOperationWithPrimitive, transformTransaction, transformTransactionWithPrimitive };
+}
+type TransformResult = TransformResult$1;
+/**
+ * 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
+ */
+declare const transformOperationWithPrimitive: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>, primitive: AnyPrimitive) => TransformResult;
+/**
+ * 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).
+ */
+declare const transformOperation: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>) => TransformResult;
+/**
+ * Transforms all operations in a client transaction against a server transaction.
+ * Uses the primitive's transformOperation for schema-aware transformation.
+ */
+declare const transformTransactionWithPrimitive: (clientTx: Transaction, serverTx: Transaction, primitive: AnyPrimitive) => Transaction;
+/**
+ * Transforms all operations in a client transaction against a server transaction.
+ * This is a standalone version that doesn't require a primitive.
+ */
+declare const transformTransaction: (clientTx: Transaction, serverTx: Transaction) => Transaction;
+/**
+ * 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.
+ */
+declare const rebasePendingTransactionsWithPrimitive: (pendingTxs: ReadonlyArray<Transaction>, serverTx: Transaction, primitive: AnyPrimitive) => Transaction[];
+/**
+ * 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.
+ */
+declare const rebasePendingTransactions: (pendingTxs: ReadonlyArray<Transaction>, serverTx: Transaction) => Transaction[];
+/**
+ * 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
+ */
+declare const rebaseAfterRejectionWithPrimitive: (originalPendingTxs: ReadonlyArray<Transaction>, rejectedTxId: string, serverTxsSinceOriginal: ReadonlyArray<Transaction>, primitive: AnyPrimitive) => Transaction[];
+/**
+ * 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
+ */
+declare const rebaseAfterRejection: (originalPendingTxs: ReadonlyArray<Transaction>, rejectedTxId: string, serverTxsSinceOriginal: ReadonlyArray<Transaction>) => Transaction[];
+//#endregion
+export { Rebase_d_exports };
+//# sourceMappingURL=Rebase.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Rebase.d.cts","names":[],"sources":["../../src/client/Rebase.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAUY,eAAA,GAAkB;;;;;;;;;;;;cAiBjB,4CACD,oCACA,qCACC,iBACV;;AArBH;AAiBA;;;;;;AAkBA;;AAEY,cAFC,kBAED,EAAA,CAAA,QAAA,EADA,SACA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,QAAA,EAAA,SAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,GACT,eADS;;;AA6EZ;;AAEY,cAFC,iCAED,EAAA,CAAA,QAAA,EADA,WACA,EAAA,QAAA,EAAA,WAAA,EAAA,SAAA,EACC,YADD,EAAA,GAET,WAFS;;;;AA6CZ;AACY,cADC,oBACD,EAAA,CAAA,QAAA,EAAA,WAAA,EAAA,QAAA,EACA,WADA,EAAA,GAET,WAFS;;;;AAgDZ;;;;AAGa,cAHA,sCAGA,EAAA,CAAA,UAAA,EAFC,aAED,CAFe,WAEf,CAAA,EAAA,QAAA,EADD,WACC,EAAA,SAAA,EAAA,YAAA,EAAA,GACV,WADU,EAAA;;;AAcb;;;;;AAG0B,cAHb,yBAGa,EAAA,CAAA,UAAA,EAFZ,aAEY,CAFE,WAEF,CAAA,EAAA,QAAA,EADd,WACc,EAAA,GAAvB,WAAuB,EAAA;AAkB1B;;;;;;;;AAgCA;;;;AAG0B,cAnCb,iCAmCa,EAAA,CAAA,kBAAA,EAlCJ,aAkCI,CAlCU,WAkCV,CAAA,EAAA,YAAA,EAAA,MAAA,EAAA,sBAAA,EAhCA,aAgCA,CAhCc,WAgCd,CAAA,EAAA,SAAA,EA/Bb,YA+Ba,EAAA,GA9BvB,WA8BuB,EAAA;;;;;;;;;;;;cAHb,2CACS,cAAc,4DAEV,cAAc,iBACrC"}

package/dist/client/Rebase.d.mts

@@ -0,0 +1,88 @@
+import { Operation } from "../Operation.mjs";
+import { Transaction } from "../Transaction.mjs";
+import { TransformResult as TransformResult$1 } from "../Transform.mjs";
+import { AnyPrimitive } from "../primitives/shared.mjs";
+import "../Primitive.mjs";
+
+//#region src/client/Rebase.d.ts
+declare namespace Rebase_d_exports {
+  export { TransformResult, rebaseAfterRejection, rebaseAfterRejectionWithPrimitive, rebasePendingTransactions, rebasePendingTransactionsWithPrimitive, transformOperation, transformOperationWithPrimitive, transformTransaction, transformTransactionWithPrimitive };
+}
+type TransformResult = TransformResult$1;
+/**
+ * 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
+ */
+declare const transformOperationWithPrimitive: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>, primitive: AnyPrimitive) => TransformResult;
+/**
+ * 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).
+ */
+declare const transformOperation: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>) => TransformResult;
+/**
+ * Transforms all operations in a client transaction against a server transaction.
+ * Uses the primitive's transformOperation for schema-aware transformation.
+ */
+declare const transformTransactionWithPrimitive: (clientTx: Transaction, serverTx: Transaction, primitive: AnyPrimitive) => Transaction;
+/**
+ * Transforms all operations in a client transaction against a server transaction.
+ * This is a standalone version that doesn't require a primitive.
+ */
+declare const transformTransaction: (clientTx: Transaction, serverTx: Transaction) => Transaction;
+/**
+ * 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.
+ */
+declare const rebasePendingTransactionsWithPrimitive: (pendingTxs: ReadonlyArray<Transaction>, serverTx: Transaction, primitive: AnyPrimitive) => Transaction[];
+/**
+ * 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.
+ */
+declare const rebasePendingTransactions: (pendingTxs: ReadonlyArray<Transaction>, serverTx: Transaction) => Transaction[];
+/**
+ * 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
+ */
+declare const rebaseAfterRejectionWithPrimitive: (originalPendingTxs: ReadonlyArray<Transaction>, rejectedTxId: string, serverTxsSinceOriginal: ReadonlyArray<Transaction>, primitive: AnyPrimitive) => Transaction[];
+/**
+ * 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
+ */
+declare const rebaseAfterRejection: (originalPendingTxs: ReadonlyArray<Transaction>, rejectedTxId: string, serverTxsSinceOriginal: ReadonlyArray<Transaction>) => Transaction[];
+//#endregion
+export { Rebase_d_exports };
+//# sourceMappingURL=Rebase.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Rebase.d.mts","names":[],"sources":["../../src/client/Rebase.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAUY,eAAA,GAAkB;;;;;;;;;;;;cAiBjB,4CACD,oCACA,qCACC,iBACV;;;AArBH;AAiBA;;;;;;AAkBA;AACY,cADC,kBACD,EAAA,CAAA,QAAA,EAAA,SAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,QAAA,EACA,SADA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,GAET,eAFS;;;;AA8EZ;AACY,cADC,iCACD,EAAA,CAAA,QAAA,EAAA,WAAA,EAAA,QAAA,EACA,WADA,EAAA,SAAA,EAEC,YAFD,EAAA,GAGT,WAHS;;;;;AA8CC,cAAA,oBAwCZ,EAAA,CAAA,QAAA,EAvCW,WAuCX,EAAA,QAAA,EAtCW,WAsCX,EAAA,GArCE,WAqCF;;;;;AASD;;;AAEY,cAFC,sCAED,EAAA,CAAA,UAAA,EADE,aACF,CADgB,WAChB,CAAA,EAAA,QAAA,EAAA,WAAA,EAAA,SAAA,EACC,YADD,EAAA,GAET,WAFS,EAAA;;;;AAeZ;;;;AAGG,cAHU,yBAGV,EAAA,CAAA,UAAA,EAFW,aAEX,CAFyB,WAEzB,CAAA,EAAA,QAAA,EADS,WACT,EAAA,GAAA,WAAA,EAAA;;AAkBH;;;;;;;;AAgCA;;;AAGwC,cAnC3B,iCAmC2B,EAAA,CAAA,kBAAA,EAlClB,aAkCkB,CAlCJ,WAkCI,CAAA,EAAA,YAAA,EAAA,MAAA,EAAA,sBAAA,EAhCd,aAgCc,CAhCA,WAgCA,CAAA,EAAA,SAAA,EA/B3B,YA+B2B,EAAA,GA9BrC,WA8BqC,EAAA;;;;;;;;;;;;cAH3B,2CACS,cAAc,4DAEV,cAAc,iBACrC"}