@liveblocks/core 3.13.2 → 3.13.3-rc1

package/dist/index.cjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.13.2";
+var PKG_VERSION = "3.13.3-rc1";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -2760,6 +2760,14 @@ var FSM = class {
   // `foo.bar.*`, then `foo.*`, and finally, `*`.
   //
   #cleanupStack;
+  //
+  // The entry times stack tracks when each state level was entered, using
+  // performance.now() timestamps. This parallels the cleanup stack structure.
+  //
+  // For example, if you are in state `foo.bar.qux`, the stack contains:
+  // [timestamp for *, timestamp for foo.*, timestamp for foo.bar.*, timestamp for foo.bar.qux]
+  //
+  #entryTimesStack;
   #enterFns;
   // Used to provide better error messages
   #knownEventTypes;
@@ -2816,6 +2824,7 @@ var FSM = class {
     this.#states = /* @__PURE__ */ new Set();
     this.#enterFns = /* @__PURE__ */ new Map();
     this.#cleanupStack = [];
+    this.#entryTimesStack = [];
     this.#knownEventTypes = /* @__PURE__ */ new Set();
     this.#allowedTransitions = /* @__PURE__ */ new Map();
     this.#currentContext = new SafeContext(initialContext);
@@ -2824,14 +2833,16 @@ var FSM = class {
       willTransition: makeEventSource(),
       didIgnoreEvent: makeEventSource(),
       willExitState: makeEventSource(),
-      didEnterState: makeEventSource()
+      didEnterState: makeEventSource(),
+      didExitState: makeEventSource()
     };
     this.events = {
       didReceiveEvent: this.#eventHub.didReceiveEvent.observable,
       willTransition: this.#eventHub.willTransition.observable,
       didIgnoreEvent: this.#eventHub.didIgnoreEvent.observable,
       willExitState: this.#eventHub.willExitState.observable,
-      didEnterState: this.#eventHub.didEnterState.observable
+      didEnterState: this.#eventHub.didEnterState.observable,
+      didExitState: this.#eventHub.didExitState.observable
     };
   }
   get context() {
@@ -3017,10 +3028,23 @@ var FSM = class {
    */
   #exit(levels) {
     this.#eventHub.willExitState.notify(this.currentState);
+    const now2 = performance.now();
+    const parts = this.currentState.split(".");
     this.#currentContext.allowPatching((patchableContext) => {
       levels = _nullishCoalesce(levels, () => ( this.#cleanupStack.length));
       for (let i = 0; i < levels; i++) {
         _optionalChain([this, 'access', _35 => _35.#cleanupStack, 'access', _36 => _36.pop, 'call', _37 => _37(), 'optionalCall', _38 => _38(patchableContext)]);
+        const entryTime = this.#entryTimesStack.pop();
+        if (entryTime !== void 0 && // ...but avoid computing state names if nobody is listening
+        this.#eventHub.didExitState.count() > 0) {
+          const depth = this.#entryTimesStack.length;
+          if (depth === 0) continue;
+          const state = depth === parts.length ? this.currentState : `${parts.slice(0, depth).join(".")}.*`;
+          this.#eventHub.didExitState.notify({
+            state,
+            durationMs: now2 - entryTime
+          });
+        }
       }
     });
   }
@@ -3033,6 +3057,7 @@ var FSM = class {
       this.currentState,
       _nullishCoalesce(levels, () => ( this.currentState.split(".").length + 1))
     );
+    const now2 = performance.now();
     this.#currentContext.allowPatching((patchableContext) => {
       for (const pattern of enterPatterns) {
         const enterFn = this.#enterFns.get(pattern);
@@ -3042,6 +3067,7 @@ var FSM = class {
         } else {
           this.#cleanupStack.push(null);
         }
+        this.#entryTimesStack.push(now2);
       }
     });
     this.#eventHub.didEnterState.notify(this.currentState);
@@ -3259,23 +3285,20 @@ function isCloseEvent(error3) {
   return !(error3 instanceof Error) && error3.type === "close";
 }
 function enableTracing(machine) {
-  const start = (/* @__PURE__ */ new Date()).getTime();
   function log2(...args) {
-    warn(
-      `${(((/* @__PURE__ */ new Date()).getTime() - start) / 1e3).toFixed(2)} [FSM #${machine.id}]`,
-      ...args
-    );
+    warn(`[FSM #${machine.id}]`, ...args);
   }
   const unsubs = [
     machine.events.didReceiveEvent.subscribe((e) => log2(`Event ${e.type}`)),
     machine.events.willTransition.subscribe(
       ({ from, to }) => log2("Transitioning", from, "\u2192", to)
     ),
+    machine.events.didExitState.subscribe(
+      ({ state, durationMs }) => log2(`Exited ${state} after ${durationMs.toFixed(0)}ms`)
+    ),
     machine.events.didIgnoreEvent.subscribe(
       (e) => log2("Ignored event", e.type, e, "(current state won't handle it)")
     )
-    // machine.events.willExitState.subscribe((s) => log("Exiting state", s)),
-    // machine.events.didEnterState.subscribe((s) => log("Entering state", s)),
   ];
   return () => {
     for (const unsub of unsubs) {
@@ -3416,6 +3439,8 @@ function createConnectionStateMachine(delegates, options) {
     // OK state. This is done by resolving the Promise.
     //
     async (ctx, signal) => {
+      const socketEpoch = performance.now();
+      let socketOpenAt = null;
       let capturedPrematureEvent = null;
       let unconfirmedSocket = null;
       const connect$ = new Promise(
@@ -3437,6 +3462,12 @@ function createConnectionStateMachine(delegates, options) {
           function waitForActorId(event) {
             const serverMsg = tryParseJson(event.data);
             if (_optionalChain([serverMsg, 'optionalAccess', _40 => _40.type]) === ServerMsgCode.ROOM_STATE) {
+              if (options.enableDebugLogging && socketOpenAt !== null) {
+                const elapsed = performance.now() - socketOpenAt;
+                warn(
+                  `[FSM #${machine.id}] Socket open \u2192 ROOM_STATE: ${elapsed.toFixed(0)}ms`
+                );
+              }
               didReceiveActor();
             }
           }
@@ -3447,6 +3478,13 @@ function createConnectionStateMachine(delegates, options) {
           socket.addEventListener("error", reject);
           socket.addEventListener("close", reject);
           socket.addEventListener("open", () => {
+            socketOpenAt = performance.now();
+            if (options.enableDebugLogging) {
+              const elapsed = socketOpenAt - socketEpoch;
+              warn(
+                `[FSM #${machine.id}] Socket epoch \u2192 open: ${elapsed.toFixed(0)}ms`
+              );
+            }
             socket.addEventListener("error", onSocketError);
             socket.addEventListener("close", onSocketClose);
             const unsub = () => {
@@ -5952,7 +5990,7 @@ var OpCode = Object.freeze({
   CREATE_MAP: 7,
   CREATE_REGISTER: 8
 });
-function isAckOp(op) {
+function isIgnoredOp(op) {
   return op.type === OpCode.DELETE_CRDT && op.id === "ACK";
 }
 
@@ -9292,7 +9330,7 @@ function createRoom(options, config) {
     };
   }
   function applyOp(op, source) {
-    if (isAckOp(op)) {
+    if (isIgnoredOp(op)) {
       return { modified: false };
     }
     switch (op.type) {