Fixed ably-js parity issues in path-based liveobjects API implementation

- PathObject path parsing: exact port of the ably-js escape algorithm
  (backslash before a non-dot is kept literally, so an escaped backslash
  no longer suppresses the dot split; trailing backslash kept as-is)
- PathObjectSubscriptionRegister: deliver one event per full path to the
  updated object, so an object reachable via several covered paths
  notifies subscribers once per path (mirrors
  liveobject.ts#_notifyPathSubscriptions)
- size()/keys()/entries() on map path objects and size() on map
  instances now exclude entries with unresolvable (dangling/tombstoned)
  object references, per RTLM10d/RTLM14
- Added parity tests for escaped-backslash parsing, multi-path event
  delivery, and unresolvable-reference filtering

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sacOO7

liveobjects/src/main/kotlin/io/ably/lib/object/PathObjectSubscriptionRegister.kt

@@ -63,10 +63,6 @@ internal class PathObjectSubscriptionRegister(private val bridge: ObjectsBridge)
     val fullPaths = PathFinder.findFullPaths(bridge, objectId)
     if (fullPaths.isEmpty()) return // object not reachable from root
 
-    val candidatePaths = fullPaths.flatMap { fullPath ->
-      listOf(fullPath) + updatedKeys.map { key -> fullPath + key }
-    }
-
     val publicMessage = message?.let {
       try {
         it.toPublicMessage(bridge.channelName)
@@ -76,17 +72,23 @@ internal class PathObjectSubscriptionRegister(private val bridge: ObjectsBridge)
       }
     }
 
-    for (entry in subscriptions.values) {
-      // first candidate covered by this subscription wins (priority order)
-      val coveredPath = candidatePaths.firstOrNull { coversPath(entry.path, entry.depth, it) } ?: continue
-      val event = DefaultPathObjectSubscriptionEvent(
-        DefaultPathObject(bridge, coveredPath), // RTPO19e1
-        publicMessage, // RTPO19e2
-      )
-      try {
-        entry.listener.onUpdated(event)
-      } catch (t: Throwable) {
-        Log.e(tag, "Error in PathObjectListener callback", t)
+    // one event per full path to the object (an object reachable via several
+    // covered paths notifies once per path), exactly like ably-js
+    // liveobject.ts#_notifyPathSubscriptions
+    for (fullPath in fullPaths) {
+      val candidatePaths = listOf(fullPath) + updatedKeys.map { key -> fullPath + key }
+      for (entry in subscriptions.values) {
+        // first candidate covered by this subscription wins (priority order)
+        val coveredPath = candidatePaths.firstOrNull { coversPath(entry.path, entry.depth, it) } ?: continue
+        val event = DefaultPathObjectSubscriptionEvent(
+          DefaultPathObject(bridge, coveredPath), // RTPO19e1
+          publicMessage, // RTPO19e2
+        )
+        try {
+          entry.listener.onUpdated(event)
+        } catch (t: Throwable) {
+          Log.e(tag, "Error in PathObjectListener callback", t)
+        }
       }
     }
   }

liveobjects/src/main/kotlin/io/ably/lib/object/instance/DefaultLiveMapInstance.kt

@@ -64,10 +64,10 @@ internal class DefaultLiveMapInstance(
   /** Spec: RTINS8 */
   override fun values(): Iterable<Instance> = entries().map { it.value }
 
-  /** Spec: RTINS9 / RTTS10a - non-null (the wrapped value is always a map) */
+  /** Spec: RTINS9 / RTTS10a - non-null; counts resolvable entries only (RTLM10d/RTLM14) */
   override fun size(): Long {
     bridge.throwIfInvalidAccessApiConfiguration() // RTO25
-    return mapNodeOrThrow().entries().size.toLong()
+    return mapNodeOrThrow().entries().count { (_, data) -> data.resolve(bridge) != null }.toLong()
   }
 
   /** Spec: RTINS12 */

liveobjects/src/main/kotlin/io/ably/lib/object/path/DefaultBasePathObject.kt

@@ -101,33 +101,38 @@ internal abstract class DefaultBasePathObject(
 
   internal companion object {
     /**
-     * Parses a dot-delimited path string into segments; a backslash-escaped
-     * dot (`\.`) is a literal dot within a segment.
+     * Parses a dot-delimited path string into segments: splits on unescaped
+     * dots; a backslash-escaped dot (`\.`) is a literal dot within a segment;
+     * a backslash before any other character is kept as-is. Exact port of the
+     * ably-js algorithm (pathobject.ts#at) so the two SDKs agree on every
+     * input, including escaped backslashes and trailing backslashes.
      *
      * Spec: RTPO6 (and the inverse of RTPO4b)
      */
     internal fun parsePath(path: String): List<String> {
       val segments = mutableListOf<String>()
       val current = StringBuilder()
-      var i = 0
-      while (i < path.length) {
-        val c = path[i]
-        when {
-          c == '\\' && i + 1 < path.length && path[i + 1] == '.' -> {
-            current.append('.')
-            i += 2
-          }
-          c == '.' -> {
+      var escaping = false
+      for (c in path) {
+        if (escaping) {
+          // keep the escape character if not escaping a dot
+          if (c != '.') current.append('\\')
+          current.append(c)
+          escaping = false
+          continue
+        }
+        when (c) {
+          '\\' -> escaping = true
+          '.' -> {
             segments.add(current.toString())
             current.setLength(0)
-            i++
-          }
-          else -> {
-            current.append(c)
-            i++
           }
+          else -> current.append(c)
         }
       }
+      if (escaping) {
+        current.append('\\')
+      }
       segments.add(current.toString())
       return segments
     }

liveobjects/src/main/kotlin/io/ably/lib/object/path/DefaultLiveMapPathObject.kt

@@ -12,6 +12,7 @@ import io.ably.lib.`object`.invalidInputError
 import io.ably.lib.`object`.objectDataFrom
 import io.ably.lib.`object`.path.types.LiveMapPathObject
 import io.ably.lib.`object`.pathNotResolvedError
+import io.ably.lib.`object`.resolve
 import io.ably.lib.`object`.typeMismatchError
 import io.ably.lib.`object`.value.LiveMapValue
 import java.util.AbstractMap
@@ -36,6 +37,14 @@ internal class DefaultLiveMapPathObject(
 
   private fun mapNodeOrNull(): MapNode? = (resolve() as? ResolvedValue.MapRef)?.map
 
+  /**
+   * Keys of the resolved map whose entries themselves resolve - entries
+   * referencing missing/tombstoned objects are excluded, matching the
+   * underlying map semantics (RTLM11d2/RTLM14).
+   */
+  private fun resolvableKeys(node: MapNode): List<String> =
+    node.entries().filter { (_, data) -> data.resolve(bridge) != null }.map { it.key }
+
   /** Spec: RTPO5 - purely navigational, no resolution performed */
   override fun get(key: String): PathObject = DefaultPathObject(bridge, pathSegments + key)
 
@@ -47,7 +56,7 @@ internal class DefaultLiveMapPathObject(
   override fun entries(): Iterable<Map.Entry<String, PathObject>> {
     bridge.throwIfInvalidAccessApiConfiguration() // RTPO9a / RTO25
     val node = mapNodeOrNull() ?: return emptyList()
-    return node.entries().keys.map { key ->
+    return resolvableKeys(node).map { key ->
       AbstractMap.SimpleImmutableEntry<String, PathObject>(key, get(key)) // child paths as if by get(key)
     }
   }
@@ -56,16 +65,16 @@ internal class DefaultLiveMapPathObject(
   override fun keys(): Iterable<String> {
     bridge.throwIfInvalidAccessApiConfiguration() // RTPO10a / RTO25
     val node = mapNodeOrNull() ?: return emptyList()
-    return node.entries().keys.toList()
+    return resolvableKeys(node)
   }
 
   /** Spec: RTPO11 */
   override fun values(): Iterable<PathObject> = entries().map { it.value }
 
-  /** Spec: RTPO12 - null when the path does not resolve to a map */
+  /** Spec: RTPO12 - null when the path does not resolve to a map; counts resolvable entries (RTLM10d) */
   override fun size(): Long? {
     bridge.throwIfInvalidAccessApiConfiguration() // RTPO12a / RTO25
-    return mapNodeOrNull()?.entries()?.size?.toLong()
+    return mapNodeOrNull()?.let { resolvableKeys(it).size.toLong() }
   }
 
   /** Spec: RTPO15 */

liveobjects/src/test/kotlin/io/ably/lib/object/unit/PathApiTest.kt

@@ -48,6 +48,11 @@ internal class PathApiTest {
     // RTPO6 - parsing honours the escape
     assertEquals(listOf("a.b", "c"), DefaultBasePathObject.parsePath("a\\.b.c"))
     assertEquals(listOf("users", "emma"), DefaultBasePathObject.parsePath("users.emma"))
+    // ably-js parity: a backslash NOT escaping a dot is kept as-is, so an
+    // escaped backslash before a dot does not suppress the split
+    assertEquals(listOf("a\\\\", "b"), DefaultBasePathObject.parsePath("a\\\\.b"))
+    // ably-js parity: trailing backslash is kept literally
+    assertEquals(listOf("x\\"), DefaultBasePathObject.parsePath("x\\"))
   }
 
   @Test
@@ -164,6 +169,34 @@ internal class PathApiTest {
     assertEquals(1, events.size)
   }
 
+  @Test
+  fun `object reachable via several covered paths notifies once per path`() {
+    val bridge = graphBridge()
+    // second reference to the same counter directly under root
+    (bridge.nodes["root"] as FakeMapNode).data["topScore"] = WireObjectData(objectId = "counter:score@1")
+
+    val events = mutableListOf<String>()
+    DefaultLiveMapPathObject(bridge, emptyList()).subscribe { events.add(it.getObject().path()) }
+
+    bridge.notifyUpdated("counter:score@1", emptySet(), null)
+
+    // ably-js parity (liveobject.ts#_notifyPathSubscriptions): one event per full path
+    assertEquals(setOf("profile.score", "topScore"), events.toSet())
+    assertEquals(2, events.size)
+  }
+
+  @Test
+  fun `size and keys exclude entries with unresolvable references`() {
+    val bridge = graphBridge()
+    // dangling reference - the target object does not exist in the pool
+    (bridge.nodes["root"] as FakeMapNode).data["ghost"] = WireObjectData(objectId = "map:deleted@1")
+
+    val root = DefaultLiveMapPathObject(bridge, emptyList())
+    assertEquals(2L, root.size()) // RTLM10d/RTLM14 - ghost not counted
+    assertEquals(setOf("profile", "flag"), root.keys().toSet())
+    assertEquals(2L, root.instance()!!.asLiveMap().size()) // RTINS9 - same filtering
+  }
+
   @Test
   fun `instance subscriptions deliver events with the public message`() {
     val bridge = graphBridge()