@liveblocks/core 3.20.0-exp7 → 3.20.0-exp8

package/dist/index.d.cts

@@ -951,6 +951,22 @@ type LiveTextUpdates = {
     updates: LiveTextChange[];
 };
 
+/**
+ * LiveText is a collaborative rich-text primitive built on server-ordered
+ * operational transformation.
+ *
+ * Outbound model (one-in-flight): at most one UpdateTextOp per node is
+ * awaiting server acknowledgement at any time. Local edits made while an op
+ * is in flight are queued and sent (composed into a single op) once the ack
+ * arrives. This guarantees every wire op is expressed against server-state
+ * coordinates, so the server can transform it over exactly the (foreign)
+ * ops the client hadn't seen — never over the client's own pending ops.
+ *
+ * Inbound model: accepted remote ops are transformed over the local pending
+ * ops before being applied ("before" order: the accepted op wins ties), and
+ * the pending ops are re-expressed over the remote op in turn ("after"
+ * order), keeping them in server coordinates at all times.
+ */
 declare class LiveText extends AbstractCrdt {
     #private;
     constructor(textOrData?: string | LiveTextData, version?: number);
@@ -1001,6 +1017,16 @@ interface ReadonlyUnacknowledgedOps {
     isPossiblyStored(opId: string): boolean;
 }
 
+type DispatchOptions = {
+    /**
+     * Whether this dispatch should clear the redo stack. Defaults to true when
+     * any forward ops are included (a fresh local mutation), false otherwise.
+     * LiveText uses this to dispatch queued ops after an acknowledgement
+     * (which should not clear redo), and to register fresh local edits that
+     * don't carry wire ops yet (which should).
+     */
+    clearRedoStack?: boolean;
+};
 /**
  * The managed pool is a namespace registry (i.e. a context) that "owns" all
  * the individual live nodes, ensuring each one has a unique ID, and holding on
@@ -1020,7 +1046,7 @@ interface ManagedPool {
      * - Add reverse operations to the undo/redo stack
      * - Notify room subscribers with updates (in-client, no networking)
      */
-    dispatch: (ops: ClientWireOp[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
+    dispatch: (ops: ClientWireOp[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>, options?: DispatchOptions) => void;
     /**
      * Ensures storage can be written to else throws an error.
      * This is used to prevent writing to storage when the user does not have
@@ -1045,7 +1071,7 @@ type CreateManagedPoolOptions = {
     /**
      * Will get invoked when any Live structure calls .dispatch() on the pool.
      */
-    onDispatch?: (ops: ClientWireOp[], reverse: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
+    onDispatch?: (ops: ClientWireOp[], reverse: Op[], storageUpdates: Map<string, StorageUpdate>, options?: DispatchOptions) => void;
     /**
      * Will get invoked when any Live structure calls .assertStorageIsWritable()
      * on the pool. Defaults to true when not provided. Return false if you want

package/dist/index.d.ts

@@ -951,6 +951,22 @@ type LiveTextUpdates = {
     updates: LiveTextChange[];
 };
 
+/**
+ * LiveText is a collaborative rich-text primitive built on server-ordered
+ * operational transformation.
+ *
+ * Outbound model (one-in-flight): at most one UpdateTextOp per node is
+ * awaiting server acknowledgement at any time. Local edits made while an op
+ * is in flight are queued and sent (composed into a single op) once the ack
+ * arrives. This guarantees every wire op is expressed against server-state
+ * coordinates, so the server can transform it over exactly the (foreign)
+ * ops the client hadn't seen — never over the client's own pending ops.
+ *
+ * Inbound model: accepted remote ops are transformed over the local pending
+ * ops before being applied ("before" order: the accepted op wins ties), and
+ * the pending ops are re-expressed over the remote op in turn ("after"
+ * order), keeping them in server coordinates at all times.
+ */
 declare class LiveText extends AbstractCrdt {
     #private;
     constructor(textOrData?: string | LiveTextData, version?: number);
@@ -1001,6 +1017,16 @@ interface ReadonlyUnacknowledgedOps {
     isPossiblyStored(opId: string): boolean;
 }
 
+type DispatchOptions = {
+    /**
+     * Whether this dispatch should clear the redo stack. Defaults to true when
+     * any forward ops are included (a fresh local mutation), false otherwise.
+     * LiveText uses this to dispatch queued ops after an acknowledgement
+     * (which should not clear redo), and to register fresh local edits that
+     * don't carry wire ops yet (which should).
+     */
+    clearRedoStack?: boolean;
+};
 /**
  * The managed pool is a namespace registry (i.e. a context) that "owns" all
  * the individual live nodes, ensuring each one has a unique ID, and holding on
@@ -1020,7 +1046,7 @@ interface ManagedPool {
      * - Add reverse operations to the undo/redo stack
      * - Notify room subscribers with updates (in-client, no networking)
      */
-    dispatch: (ops: ClientWireOp[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
+    dispatch: (ops: ClientWireOp[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>, options?: DispatchOptions) => void;
     /**
      * Ensures storage can be written to else throws an error.
      * This is used to prevent writing to storage when the user does not have
@@ -1045,7 +1071,7 @@ type CreateManagedPoolOptions = {
     /**
      * Will get invoked when any Live structure calls .dispatch() on the pool.
      */
-    onDispatch?: (ops: ClientWireOp[], reverse: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
+    onDispatch?: (ops: ClientWireOp[], reverse: Op[], storageUpdates: Map<string, StorageUpdate>, options?: DispatchOptions) => void;
     /**
      * Will get invoked when any Live structure calls .assertStorageIsWritable()
      * on the pool. Defaults to true when not provided. Return false if you want