@yorkie-js/sdk 0.7.5 → 0.7.7

package/dist/yorkie-js-sdk.es.js

@@ -5788,7 +5788,7 @@ function createGrpcWebTransport(options) {
     }
   };
 }
-const file_src_api_yorkie_v1_resources = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_protobuf_wrappers]);
+const file_src_api_yorkie_v1_resources = /* @__PURE__ */ fileDesc("CiFzcmMvYXBpL3lvcmtpZS92MS9yZXNvdXJjZXMucHJvdG8SCXlvcmtpZS52MSKuAQoIU25hcHNob3QSJAoEcm9vdBgBIAEoCzIWLnlvcmtpZS52MS5KU09ORWxlbWVudBI1CglwcmVzZW5jZXMYAiADKAsyIi55b3JraWUudjEuU25hcHNob3QuUHJlc2VuY2VzRW50cnkaRQoOUHJlc2VuY2VzRW50cnkSCwoDa2V5GAEgASgJEiIKBXZhbHVlGAIgASgLMhMueW9ya2llLnYxLlByZXNlbmNlOgI4ASL7AQoKQ2hhbmdlUGFjaxIUCgxkb2N1bWVudF9rZXkYASABKAkSKQoKY2hlY2twb2ludBgCIAEoCzIVLnlvcmtpZS52MS5DaGVja3BvaW50EhAKCHNuYXBzaG90GAMgASgMEiIKB2NoYW5nZXMYBCADKAsyES55b3JraWUudjEuQ2hhbmdlEjAKEW1pbl9zeW5jZWRfdGlja2V0GAUgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSEgoKaXNfcmVtb3ZlZBgGIAEoCBIwCg52ZXJzaW9uX3ZlY3RvchgHIAEoCzIYLnlvcmtpZS52MS5WZXJzaW9uVmVjdG9yIpgBCgZDaGFuZ2USHwoCaWQYASABKAsyEy55b3JraWUudjEuQ2hhbmdlSUQSDwoHbWVzc2FnZRgCIAEoCRIoCgpvcGVyYXRpb25zGAMgAygLMhQueW9ya2llLnYxLk9wZXJhdGlvbhIyCg9wcmVzZW5jZV9jaGFuZ2UYBCABKAsyGS55b3JraWUudjEuUHJlc2VuY2VDaGFuZ2UihwEKCENoYW5nZUlEEhIKCmNsaWVudF9zZXEYASABKA0SEgoKc2VydmVyX3NlcRgCIAEoAxIPCgdsYW1wb3J0GAMgASgDEhAKCGFjdG9yX2lkGAQgASgMEjAKDnZlcnNpb25fdmVjdG9yGAUgASgLMhgueW9ya2llLnYxLlZlcnNpb25WZWN0b3IidAoNVmVyc2lvblZlY3RvchI0CgZ2ZWN0b3IYASADKAsyJC55b3JraWUudjEuVmVyc2lvblZlY3Rvci5WZWN0b3JFbnRyeRotCgtWZWN0b3JFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAM6AjgBItkaCglPcGVyYXRpb24SJwoDc2V0GAEgASgLMhgueW9ya2llLnYxLk9wZXJhdGlvbi5TZXRIABInCgNhZGQYAiABKAsyGC55b3JraWUudjEuT3BlcmF0aW9uLkFkZEgAEikKBG1vdmUYAyABKAsyGS55b3JraWUudjEuT3BlcmF0aW9uLk1vdmVIABItCgZyZW1vdmUYBCABKAsyGy55b3JraWUudjEuT3BlcmF0aW9uLlJlbW92ZUgAEikKBGVkaXQYBSABKAsyGS55b3JraWUudjEuT3BlcmF0aW9uLkVkaXRIABIrCgVzdHlsZRgHIAEoCzIaLnlvcmtpZS52MS5PcGVyYXRpb24uU3R5bGVIABIxCghpbmNyZWFzZRgIIAEoCzIdLnlvcmtpZS52MS5PcGVyYXRpb24uSW5jcmVhc2VIABIyCgl0cmVlX2VkaXQYCSABKAsyHS55b3JraWUudjEuT3BlcmF0aW9uLlRyZWVFZGl0SAASNAoKdHJlZV9zdHlsZRgKIAEoCzIeLnlvcmtpZS52MS5PcGVyYXRpb24uVHJlZVN0eWxlSAASMgoJYXJyYXlfc2V0GAsgASgLMh0ueW9ya2llLnYxLk9wZXJhdGlvbi5BcnJheVNldEgAGp0BCgNTZXQSMAoRcGFyZW50X2NyZWF0ZWRfYXQYASABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBILCgNrZXkYAiABKAkSKwoFdmFsdWUYAyABKAsyHC55b3JraWUudjEuSlNPTkVsZW1lbnRTaW1wbGUSKgoLZXhlY3V0ZWRfYXQYBCABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBrAAQoDQWRkEjAKEXBhcmVudF9jcmVhdGVkX2F0GAEgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSLgoPcHJldl9jcmVhdGVkX2F0GAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKwoFdmFsdWUYAyABKAsyHC55b3JraWUudjEuSlNPTkVsZW1lbnRTaW1wbGUSKgoLZXhlY3V0ZWRfYXQYBCABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBq/AQoETW92ZRIwChFwYXJlbnRfY3JlYXRlZF9hdBgBIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0Ei4KD3ByZXZfY3JlYXRlZF9hdBgCIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EikKCmNyZWF0ZWRfYXQYAyABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIqCgtleGVjdXRlZF9hdBgEIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0GpEBCgZSZW1vdmUSMAoRcGFyZW50X2NyZWF0ZWRfYXQYASABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIpCgpjcmVhdGVkX2F0GAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKgoLZXhlY3V0ZWRfYXQYAyABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBrZAwoERWRpdBIwChFwYXJlbnRfY3JlYXRlZF9hdBgBIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EiQKBGZyb20YAiABKAsyFi55b3JraWUudjEuVGV4dE5vZGVQb3MSIgoCdG8YAyABKAsyFi55b3JraWUudjEuVGV4dE5vZGVQb3MSUwoXY3JlYXRlZF9hdF9tYXBfYnlfYWN0b3IYBCADKAsyMi55b3JraWUudjEuT3BlcmF0aW9uLkVkaXQuQ3JlYXRlZEF0TWFwQnlBY3RvckVudHJ5Eg8KB2NvbnRlbnQYBSABKAkSKgoLZXhlY3V0ZWRfYXQYBiABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBI9CgphdHRyaWJ1dGVzGAcgAygLMikueW9ya2llLnYxLk9wZXJhdGlvbi5FZGl0LkF0dHJpYnV0ZXNFbnRyeRpRChhDcmVhdGVkQXRNYXBCeUFjdG9yRW50cnkSCwoDa2V5GAEgASgJEiQKBXZhbHVlGAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQ6AjgBGjEKD0F0dHJpYnV0ZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBGukDCgVTdHlsZRIwChFwYXJlbnRfY3JlYXRlZF9hdBgBIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EiQKBGZyb20YAiABKAsyFi55b3JraWUudjEuVGV4dE5vZGVQb3MSIgoCdG8YAyABKAsyFi55b3JraWUudjEuVGV4dE5vZGVQb3MSPgoKYXR0cmlidXRlcxgEIAMoCzIqLnlvcmtpZS52MS5PcGVyYXRpb24uU3R5bGUuQXR0cmlidXRlc0VudHJ5EioKC2V4ZWN1dGVkX2F0GAUgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSVAoXY3JlYXRlZF9hdF9tYXBfYnlfYWN0b3IYBiADKAsyMy55b3JraWUudjEuT3BlcmF0aW9uLlN0eWxlLkNyZWF0ZWRBdE1hcEJ5QWN0b3JFbnRyeRIcChRhdHRyaWJ1dGVzX3RvX3JlbW92ZRgHIAMoCRoxCg9BdHRyaWJ1dGVzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARpRChhDcmVhdGVkQXRNYXBCeUFjdG9yRW50cnkSCwoDa2V5GAEgASgJEiQKBXZhbHVlGAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQ6AjgBGqQBCghJbmNyZWFzZRIwChFwYXJlbnRfY3JlYXRlZF9hdBgBIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EisKBXZhbHVlGAIgASgLMhwueW9ya2llLnYxLkpTT05FbGVtZW50U2ltcGxlEioKC2V4ZWN1dGVkX2F0GAMgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSDQoFYWN0b3IYBCABKAkakwMKCFRyZWVFZGl0EjAKEXBhcmVudF9jcmVhdGVkX2F0GAEgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSIAoEZnJvbRgCIAEoCzISLnlvcmtpZS52MS5UcmVlUG9zEh4KAnRvGAMgASgLMhIueW9ya2llLnYxLlRyZWVQb3MSVwoXY3JlYXRlZF9hdF9tYXBfYnlfYWN0b3IYBCADKAsyNi55b3JraWUudjEuT3BlcmF0aW9uLlRyZWVFZGl0LkNyZWF0ZWRBdE1hcEJ5QWN0b3JFbnRyeRImCghjb250ZW50cxgFIAMoCzIULnlvcmtpZS52MS5UcmVlTm9kZXMSEwoLc3BsaXRfbGV2ZWwYByABKAUSKgoLZXhlY3V0ZWRfYXQYBiABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBpRChhDcmVhdGVkQXRNYXBCeUFjdG9yRW50cnkSCwoDa2V5GAEgASgJEiQKBXZhbHVlGAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQ6AjgBGu0DCglUcmVlU3R5bGUSMAoRcGFyZW50X2NyZWF0ZWRfYXQYASABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIgCgRmcm9tGAIgASgLMhIueW9ya2llLnYxLlRyZWVQb3MSHgoCdG8YAyABKAsyEi55b3JraWUudjEuVHJlZVBvcxJCCgphdHRyaWJ1dGVzGAQgAygLMi4ueW9ya2llLnYxLk9wZXJhdGlvbi5UcmVlU3R5bGUuQXR0cmlidXRlc0VudHJ5EioKC2V4ZWN1dGVkX2F0GAUgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSHAoUYXR0cmlidXRlc190b19yZW1vdmUYBiADKAkSWAoXY3JlYXRlZF9hdF9tYXBfYnlfYWN0b3IYByADKAsyNy55b3JraWUudjEuT3BlcmF0aW9uLlRyZWVTdHlsZS5DcmVhdGVkQXRNYXBCeUFjdG9yRW50cnkaMQoPQXR0cmlidXRlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEaUQoYQ3JlYXRlZEF0TWFwQnlBY3RvckVudHJ5EgsKA2tleRgBIAEoCRIkCgV2YWx1ZRgCIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0OgI4ARrAAQoIQXJyYXlTZXQSMAoRcGFyZW50X2NyZWF0ZWRfYXQYASABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIpCgpjcmVhdGVkX2F0GAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKwoFdmFsdWUYAyABKAsyHC55b3JraWUudjEuSlNPTkVsZW1lbnRTaW1wbGUSKgoLZXhlY3V0ZWRfYXQYBCABKAsyFS55b3JraWUudjEuVGltZVRpY2tldEIGCgRib2R5IsUBChFKU09ORWxlbWVudFNpbXBsZRIpCgpjcmVhdGVkX2F0GAEgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSJwoIbW92ZWRfYXQYAiABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIpCgpyZW1vdmVkX2F0GAMgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSIgoEdHlwZRgEIAEoDjIULnlvcmtpZS52MS5WYWx1ZVR5cGUSDQoFdmFsdWUYBSABKAwinwsKC0pTT05FbGVtZW50EjgKC2pzb25fb2JqZWN0GAEgASgLMiEueW9ya2llLnYxLkpTT05FbGVtZW50LkpTT05PYmplY3RIABI2Cgpqc29uX2FycmF5GAIgASgLMiAueW9ya2llLnYxLkpTT05FbGVtZW50LkpTT05BcnJheUgAEjUKCXByaW1pdGl2ZRgDIAEoCzIgLnlvcmtpZS52MS5KU09ORWxlbWVudC5QcmltaXRpdmVIABIrCgR0ZXh0GAUgASgLMhsueW9ya2llLnYxLkpTT05FbGVtZW50LlRleHRIABIxCgdjb3VudGVyGAYgASgLMh4ueW9ya2llLnYxLkpTT05FbGVtZW50LkNvdW50ZXJIABIrCgR0cmVlGAcgASgLMhsueW9ya2llLnYxLkpTT05FbGVtZW50LlRyZWVIABquAQoKSlNPTk9iamVjdBIhCgVub2RlcxgBIAMoCzISLnlvcmtpZS52MS5SSFROb2RlEikKCmNyZWF0ZWRfYXQYAiABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBInCghtb3ZlZF9hdBgDIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EikKCnJlbW92ZWRfYXQYBCABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBqtAQoJSlNPTkFycmF5EiEKBW5vZGVzGAEgAygLMhIueW9ya2llLnYxLlJHQU5vZGUSKQoKY3JlYXRlZF9hdBgCIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EicKCG1vdmVkX2F0GAMgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKQoKcmVtb3ZlZF9hdBgEIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0Gr0BCglQcmltaXRpdmUSIgoEdHlwZRgBIAEoDjIULnlvcmtpZS52MS5WYWx1ZVR5cGUSDQoFdmFsdWUYAiABKAwSKQoKY3JlYXRlZF9hdBgDIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EicKCG1vdmVkX2F0GAQgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKQoKcmVtb3ZlZF9hdBgFIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0GqkBCgRUZXh0EiIKBW5vZGVzGAEgAygLMhMueW9ya2llLnYxLlRleHROb2RlEikKCmNyZWF0ZWRfYXQYAiABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBInCghtb3ZlZF9hdBgDIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EikKCnJlbW92ZWRfYXQYBCABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBrYAQoHQ291bnRlchIiCgR0eXBlGAEgASgOMhQueW9ya2llLnYxLlZhbHVlVHlwZRINCgV2YWx1ZRgCIAEoDBIpCgpjcmVhdGVkX2F0GAMgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSJwoIbW92ZWRfYXQYBCABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIpCgpyZW1vdmVkX2F0GAUgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSFQoNaGxsX3JlZ2lzdGVycxgHIAEoDEoECAYQBxqpAQoEVHJlZRIiCgVub2RlcxgBIAMoCzITLnlvcmtpZS52MS5UcmVlTm9kZRIpCgpjcmVhdGVkX2F0GAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSJwoIbW92ZWRfYXQYAyABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIpCgpyZW1vdmVkX2F0GAQgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXRCBgoEYm9keSI/CgdSSFROb2RlEgsKA2tleRgBIAEoCRInCgdlbGVtZW50GAIgASgLMhYueW9ya2llLnYxLkpTT05FbGVtZW50Iu4BCgdSR0FOb2RlEiAKBG5leHQYASABKAsyEi55b3JraWUudjEuUkdBTm9kZRInCgdlbGVtZW50GAIgASgLMhYueW9ya2llLnYxLkpTT05FbGVtZW50EjIKE3Bvc2l0aW9uX2NyZWF0ZWRfYXQYAyABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIwChFwb3NpdGlvbl9tb3ZlZF9hdBgEIAEoCzIVLnlvcmtpZS52MS5UaW1lVGlja2V0EjIKE3Bvc2l0aW9uX3JlbW92ZWRfYXQYBSABKAsyFS55b3JraWUudjEuVGltZVRpY2tldCJYCghOb2RlQXR0chINCgV2YWx1ZRgBIAEoCRIpCgp1cGRhdGVkX2F0GAIgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSEgoKaXNfcmVtb3ZlZBgDIAEoCCKUAgoIVGV4dE5vZGUSIQoCaWQYASABKAsyFS55b3JraWUudjEuVGV4dE5vZGVJRBINCgV2YWx1ZRgCIAEoCRIpCgpyZW1vdmVkX2F0GAMgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKgoLaW5zX3ByZXZfaWQYBCABKAsyFS55b3JraWUudjEuVGV4dE5vZGVJRBI3CgphdHRyaWJ1dGVzGAUgAygLMiMueW9ya2llLnYxLlRleHROb2RlLkF0dHJpYnV0ZXNFbnRyeRpGCg9BdHRyaWJ1dGVzRW50cnkSCwoDa2V5GAEgASgJEiIKBXZhbHVlGAIgASgLMhMueW9ya2llLnYxLk5vZGVBdHRyOgI4ASJHCgpUZXh0Tm9kZUlEEikKCmNyZWF0ZWRfYXQYASABKAsyFS55b3JraWUudjEuVGltZVRpY2tldBIOCgZvZmZzZXQYAiABKAUiswMKCFRyZWVOb2RlEiEKAmlkGAEgASgLMhUueW9ya2llLnYxLlRyZWVOb2RlSUQSDAoEdHlwZRgCIAEoCRINCgV2YWx1ZRgDIAEoCRIpCgpyZW1vdmVkX2F0GAQgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSKgoLaW5zX3ByZXZfaWQYBSABKAsyFS55b3JraWUudjEuVHJlZU5vZGVJRBIqCgtpbnNfbmV4dF9pZBgGIAEoCzIVLnlvcmtpZS52MS5UcmVlTm9kZUlEEg0KBWRlcHRoGAcgASgFEjcKCmF0dHJpYnV0ZXMYCCADKAsyIy55b3JraWUudjEuVHJlZU5vZGUuQXR0cmlidXRlc0VudHJ5EioKC21lcmdlZF9mcm9tGAkgASgLMhUueW9ya2llLnYxLlRyZWVOb2RlSUQSKAoJbWVyZ2VkX2F0GAogASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQaRgoPQXR0cmlidXRlc0VudHJ5EgsKA2tleRgBIAEoCRIiCgV2YWx1ZRgCIAEoCzITLnlvcmtpZS52MS5Ob2RlQXR0cjoCOAEiMQoJVHJlZU5vZGVzEiQKB2NvbnRlbnQYASADKAsyEy55b3JraWUudjEuVHJlZU5vZGUiRwoKVHJlZU5vZGVJRBIpCgpjcmVhdGVkX2F0GAEgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSDgoGb2Zmc2V0GAIgASgFImMKB1RyZWVQb3MSKAoJcGFyZW50X2lkGAEgASgLMhUueW9ya2llLnYxLlRyZWVOb2RlSUQSLgoPbGVmdF9zaWJsaW5nX2lkGAIgASgLMhUueW9ya2llLnYxLlRyZWVOb2RlSUQiawoEVXNlchIKCgJpZBgBIAEoCRIVCg1hdXRoX3Byb3ZpZGVyGAIgASgJEhAKCHVzZXJuYW1lGAMgASgJEi4KCmNyZWF0ZWRfYXQYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIokBCgZNZW1iZXISCgoCaWQYASABKAkSEgoKcHJvamVjdF9pZBgCIAEoCRIPCgd1c2VyX2lkGAMgASgJEhAKCHVzZXJuYW1lGAQgASgJEgwKBHJvbGUYBSABKAkSLgoKaW52aXRlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAi6QYKB1Byb2plY3QSCgoCaWQYASABKAkSDAoEbmFtZRgCIAEoCRISCgpwdWJsaWNfa2V5GAMgASgJEhIKCnNlY3JldF9rZXkYBCABKAkSGAoQYXV0aF93ZWJob29rX3VybBgFIAEoCRIcChRhdXRoX3dlYmhvb2tfbWV0aG9kcxgGIAMoCRIgChhhdXRoX3dlYmhvb2tfbWF4X3JldHJpZXMYESABKAQSJgoeYXV0aF93ZWJob29rX21pbl93YWl0X2ludGVydmFsGBIgASgJEiYKHmF1dGhfd2ViaG9va19tYXhfd2FpdF9pbnRlcnZhbBgTIAEoCRIkChxhdXRoX3dlYmhvb2tfcmVxdWVzdF90aW1lb3V0GBQgASgJEhkKEWV2ZW50X3dlYmhvb2tfdXJsGAcgASgJEhwKFGV2ZW50X3dlYmhvb2tfZXZlbnRzGAggAygJEiEKGWV2ZW50X3dlYmhvb2tfbWF4X3JldHJpZXMYFSABKAQSJwofZXZlbnRfd2ViaG9va19taW5fd2FpdF9pbnRlcnZhbBgWIAEoCRInCh9ldmVudF93ZWJob29rX21heF93YWl0X2ludGVydmFsGBcgASgJEiUKHWV2ZW50X3dlYmhvb2tfcmVxdWVzdF90aW1lb3V0GBggASgJEiMKG2NsaWVudF9kZWFjdGl2YXRlX3RocmVzaG9sZBgJIAEoCRIaChJzbmFwc2hvdF90aHJlc2hvbGQYGSABKAMSGQoRc25hcHNob3RfaW50ZXJ2YWwYGiABKAMSJAocbWF4X3N1YnNjcmliZXJzX3Blcl9kb2N1bWVudBgKIAEoBRIkChxtYXhfYXR0YWNobWVudHNfcGVyX2RvY3VtZW50GAsgASgFEh0KFW1heF9zaXplX3Blcl9kb2N1bWVudBgPIAEoBRIYChByZW1vdmVfb25fZGV0YWNoGBAgASgIEh0KFWF1dG9fcmV2aXNpb25fZW5hYmxlZBgbIAEoCBIXCg9hbGxvd2VkX29yaWdpbnMYDiADKAkSLgoKY3JlYXRlZF9hdBgMIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLgoKdXBkYXRlZF9hdBgNIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiLwoLTWV0cmljUG9pbnQSEQoJdGltZXN0YW1wGAEgASgDEg0KBXZhbHVlGAIgASgFIqMMChZVcGRhdGFibGVQcm9qZWN0RmllbGRzEioKBG5hbWUYASABKAsyHC5nb29nbGUucHJvdG9idWYuU3RyaW5nVmFsdWUSNgoQYXV0aF93ZWJob29rX3VybBgCIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5TdHJpbmdWYWx1ZRJSChRhdXRoX3dlYmhvb2tfbWV0aG9kcxgDIAEoCzI0LnlvcmtpZS52MS5VcGRhdGFibGVQcm9qZWN0RmllbGRzLkF1dGhXZWJob29rTWV0aG9kcxI+ChhhdXRoX3dlYmhvb2tfbWF4X3JldHJpZXMYDCABKAsyHC5nb29nbGUucHJvdG9idWYuVUludDY0VmFsdWUSRAoeYXV0aF93ZWJob29rX21pbl93YWl0X2ludGVydmFsGA0gASgLMhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlEkQKHmF1dGhfd2ViaG9va19tYXhfd2FpdF9pbnRlcnZhbBgOIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5TdHJpbmdWYWx1ZRJCChxhdXRoX3dlYmhvb2tfcmVxdWVzdF90aW1lb3V0GA8gASgLMhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlEjcKEWV2ZW50X3dlYmhvb2tfdXJsGAQgASgLMhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlElIKFGV2ZW50X3dlYmhvb2tfZXZlbnRzGAUgASgLMjQueW9ya2llLnYxLlVwZGF0YWJsZVByb2plY3RGaWVsZHMuRXZlbnRXZWJob29rRXZlbnRzEj8KGWV2ZW50X3dlYmhvb2tfbWF4X3JldHJpZXMYECABKAsyHC5nb29nbGUucHJvdG9idWYuVUludDY0VmFsdWUSRQofZXZlbnRfd2ViaG9va19taW5fd2FpdF9pbnRlcnZhbBgRIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5TdHJpbmdWYWx1ZRJFCh9ldmVudF93ZWJob29rX21heF93YWl0X2ludGVydmFsGBIgASgLMhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlEkMKHWV2ZW50X3dlYmhvb2tfcmVxdWVzdF90aW1lb3V0GBMgASgLMhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlEjcKEnNuYXBzaG90X3RocmVzaG9sZBgUIAEoCzIbLmdvb2dsZS5wcm90b2J1Zi5JbnQ2NFZhbHVlEjYKEXNuYXBzaG90X2ludGVydmFsGBUgASgLMhsuZ29vZ2xlLnByb3RvYnVmLkludDY0VmFsdWUSQQobY2xpZW50X2RlYWN0aXZhdGVfdGhyZXNob2xkGAYgASgLMhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlEkEKHG1heF9zdWJzY3JpYmVyc19wZXJfZG9jdW1lbnQYByABKAsyGy5nb29nbGUucHJvdG9idWYuSW50MzJWYWx1ZRJBChxtYXhfYXR0YWNobWVudHNfcGVyX2RvY3VtZW50GAggASgLMhsuZ29vZ2xlLnByb3RvYnVmLkludDMyVmFsdWUSOgoVbWF4X3NpemVfcGVyX2RvY3VtZW50GAogASgLMhsuZ29vZ2xlLnByb3RvYnVmLkludDMyVmFsdWUSNAoQcmVtb3ZlX29uX2RldGFjaBgLIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5Cb29sVmFsdWUSOQoVYXV0b19yZXZpc2lvbl9lbmFibGVkGBYgASgLMhouZ29vZ2xlLnByb3RvYnVmLkJvb2xWYWx1ZRJJCg9hbGxvd2VkX29yaWdpbnMYCSABKAsyMC55b3JraWUudjEuVXBkYXRhYmxlUHJvamVjdEZpZWxkcy5BbGxvd2VkT3JpZ2lucxolChJBdXRoV2ViaG9va01ldGhvZHMSDwoHbWV0aG9kcxgBIAMoCRokChJFdmVudFdlYmhvb2tFdmVudHMSDgoGZXZlbnRzGAEgAygJGiEKDkFsbG93ZWRPcmlnaW5zEg8KB29yaWdpbnMYASADKAkipwMKD0RvY3VtZW50U3VtbWFyeRIKCgJpZBgBIAEoCRILCgNrZXkYAiABKAkSDAoEcm9vdBgDIAEoCRIYChBhdHRhY2hlZF9jbGllbnRzGAcgASgFEikKDWRvY3VtZW50X3NpemUYCCABKAsyEi55b3JraWUudjEuRG9jU2l6ZRISCgpzY2hlbWFfa2V5GAkgASgJEjwKCXByZXNlbmNlcxgKIAMoCzIpLnlvcmtpZS52MS5Eb2N1bWVudFN1bW1hcnkuUHJlc2VuY2VzRW50cnkSLgoKY3JlYXRlZF9hdBgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLwoLYWNjZXNzZWRfYXQYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEi4KCnVwZGF0ZWRfYXQYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wGkUKDlByZXNlbmNlc0VudHJ5EgsKA2tleRgBIAEoCRIiCgV2YWx1ZRgCIAEoCzITLnlvcmtpZS52MS5QcmVzZW5jZToCOAEi2gEKDlByZXNlbmNlQ2hhbmdlEjIKBHR5cGUYASABKA4yJC55b3JraWUudjEuUHJlc2VuY2VDaGFuZ2UuQ2hhbmdlVHlwZRIlCghwcmVzZW5jZRgCIAEoCzITLnlvcmtpZS52MS5QcmVzZW5jZSJtCgpDaGFuZ2VUeXBlEhsKF0NIQU5HRV9UWVBFX1VOU1BFQ0lGSUVEEAASEwoPQ0hBTkdFX1RZUEVfUFVUEAESFgoSQ0hBTkdFX1RZUEVfREVMRVRFEAISFQoRQ0hBTkdFX1RZUEVfQ0xFQVIQAyJkCghQcmVzZW5jZRIrCgRkYXRhGAEgAygLMh0ueW9ya2llLnYxLlByZXNlbmNlLkRhdGFFbnRyeRorCglEYXRhRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASI0Cg5DaGFubmVsU3VtbWFyeRILCgNrZXkYASABKAkSFQoNc2Vzc2lvbl9jb3VudBgCIAEoBSI0CgpDaGVja3BvaW50EhIKCnNlcnZlcl9zZXEYASABKAMSEgoKY2xpZW50X3NlcRgCIAEoDSJhCgtUZXh0Tm9kZVBvcxIpCgpjcmVhdGVkX2F0GAEgASgLMhUueW9ya2llLnYxLlRpbWVUaWNrZXQSDgoGb2Zmc2V0GAIgASgFEhcKD3JlbGF0aXZlX29mZnNldBgDIAEoBSJCCgpUaW1lVGlja2V0Eg8KB2xhbXBvcnQYASABKAMSEQoJZGVsaW1pdGVyGAIgASgNEhAKCGFjdG9yX2lkGAMgASgMIi4KDERvY0V2ZW50Qm9keRINCgV0b3BpYxgBIAEoCRIPCgdwYXlsb2FkGAIgASgMImsKCERvY0V2ZW50EiUKBHR5cGUYASABKA4yFy55b3JraWUudjEuRG9jRXZlbnRUeXBlEhEKCXB1Ymxpc2hlchgCIAEoCRIlCgRib2R5GAMgASgLMhcueW9ya2llLnYxLkRvY0V2ZW50Qm9keSLWAQoMQ2hhbm5lbEV2ZW50EioKBHR5cGUYASABKA4yHC55b3JraWUudjEuQ2hhbm5lbEV2ZW50LlR5cGUSEQoJcHVibGlzaGVyGAIgASgJEhUKDXNlc3Npb25fY291bnQYAyABKAMSCwoDc2VxGAQgASgDEg0KBXRvcGljGAUgASgJEg8KB3BheWxvYWQYBiABKAwiQwoEVHlwZRIUChBUWVBFX1VOU1BFQ0lGSUVEEAASEQoNVFlQRV9QUkVTRU5DRRABEhIKDlRZUEVfQlJPQURDQVNUEAIiJgoIRGF0YVNpemUSDAoEZGF0YRgBIAEoBRIMCgRtZXRhGAIgASgFIk0KB0RvY1NpemUSIQoEbGl2ZRgBIAEoCzITLnlvcmtpZS52MS5EYXRhU2l6ZRIfCgJnYxgCIAEoCzITLnlvcmtpZS52MS5EYXRhU2l6ZSKRAQoGU2NoZW1hEgoKAmlkGAEgASgJEgwKBG5hbWUYAiABKAkSDwoHdmVyc2lvbhgDIAEoBRIMCgRib2R5GAQgASgJEh4KBXJ1bGVzGAUgAygLMg8ueW9ya2llLnYxLlJ1bGUSLgoKY3JlYXRlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiUAoMVHJlZU5vZGVSdWxlEhEKCW5vZGVfdHlwZRgBIAEoCRIPCgdjb250ZW50GAIgASgJEg0KBW1hcmtzGAMgASgJEg0KBWdyb3VwGAQgASgJIk8KBFJ1bGUSDAoEcGF0aBgBIAEoCRIMCgR0eXBlGAIgASgJEisKCnRyZWVfbm9kZXMYAyADKAsyFy55b3JraWUudjEuVHJlZU5vZGVSdWxlIoMBCg9SZXZpc2lvblN1bW1hcnkSCgoCaWQYASABKAkSDQoFbGFiZWwYAiABKAkSEwoLZGVzY3JpcHRpb24YAyABKAkSEAoIc25hcHNob3QYBCABKAkSLgoKY3JlYXRlZF9hdBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAq/AIKCVZhbHVlVHlwZRITCg9WQUxVRV9UWVBFX05VTEwQABIWChJWQUxVRV9UWVBFX0JPT0xFQU4QARIWChJWQUxVRV9UWVBFX0lOVEVHRVIQAhITCg9WQUxVRV9UWVBFX0xPTkcQAxIVChFWQUxVRV9UWVBFX0RPVUJMRRAEEhUKEVZBTFVFX1RZUEVfU1RSSU5HEAUSFAoQVkFMVUVfVFlQRV9CWVRFUxAGEhMKD1ZBTFVFX1RZUEVfREFURRAHEhoKFlZBTFVFX1RZUEVfSlNPTl9PQkpFQ1QQCBIZChVWQUxVRV9UWVBFX0pTT05fQVJSQVkQCRITCg9WQUxVRV9UWVBFX1RFWFQQChIaChZWQUxVRV9UWVBFX0lOVEVHRVJfQ05UEAsSFwoTVkFMVUVfVFlQRV9MT05HX0NOVBAMEhMKD1ZBTFVFX1RZUEVfVFJFRRANEiAKHFZBTFVFX1RZUEVfSU5URUdFUl9ERURVUF9DTlQQDiIECA8QDyqmAQoMRG9jRXZlbnRUeXBlEiMKH0RPQ19FVkVOVF9UWVBFX0RPQ1VNRU5UX0NIQU5HRUQQABIjCh9ET0NfRVZFTlRfVFlQRV9ET0NVTUVOVF9XQVRDSEVEEAESJQohRE9DX0VWRU5UX1RZUEVfRE9DVU1FTlRfVU5XQVRDSEVEEAISJQohRE9DX0VWRU5UX1RZUEVfRE9DVU1FTlRfQlJPQURDQVNUEANCRQoRZGV2LnlvcmtpZS5hcGkudjFQAVouZ2l0aHViLmNvbS95b3JraWUtdGVhbS95b3JraWUvYXBpL3lvcmtpZS92MTt2MWIGcHJvdG8z", [file_google_protobuf_timestamp, file_google_protobuf_wrappers]);
 const SnapshotSchema = /* @__PURE__ */ messageDesc(file_src_api_yorkie_v1_resources, 0);
 const ChangePackSchema = /* @__PURE__ */ messageDesc(file_src_api_yorkie_v1_resources, 1);
 const ChangeSchema = /* @__PURE__ */ messageDesc(file_src_api_yorkie_v1_resources, 2);
@@ -7137,6 +7137,13 @@ class Primitive extends CRDTElement {
     if (this.valueType === 5) {
       return `"${escapeString(this.value)}"`;
     }
+    if (this.valueType === 6) {
+      const bytes = this.value;
+      return `"${btoa(String.fromCharCode(...bytes))}"`;
+    }
+    if (this.valueType === 7) {
+      return `"${this.value.toISOString()}"`;
+    }
     return `${this.value}`;
   }
   /**
@@ -7279,19 +7286,54 @@ class Primitive extends CRDTElement {
     }
   }
 }
+class ElementEntry {
+  elem;
+  positionNode;
+  posMovedAt;
+  constructor(elem) {
+    this.elem = elem;
+  }
+}
 class RGATreeListNode extends SplayNode {
+  _elementEntry;
+  _createdAt;
+  _removedAt;
   prev;
   next;
-  movedFrom;
-  constructor(value) {
-    super(value);
-    this.value = value;
+  constructor(elem, createdAt) {
+    super(elem);
+    this._createdAt = createdAt;
+  }
+  /**
+   * `createWithElement` creates a new node that owns an element.
+   */
+  static createWithElement(elem) {
+    const entry = new ElementEntry(elem);
+    const node = new RGATreeListNode(elem, elem.getCreatedAt());
+    entry.positionNode = node;
+    node._elementEntry = entry;
+    return node;
+  }
+  /**
+   * `createBarePosition` creates a position node without an element
+   * (used for move).
+   */
+  static createBarePosition(createdAt) {
+    return new RGATreeListNode(void 0, createdAt);
   }
   /**
-   * `createAfter` creates a new node after the given node.
+   * `createAfter` creates a new node with the given element after
+   * the given prev node.
    */
-  static createAfter(prev, value) {
-    const newNode = new RGATreeListNode(value);
+  static createAfter(prev, elem) {
+    const newNode = RGATreeListNode.createWithElement(elem);
+    RGATreeListNode.insertNodeAfter(prev, newNode);
+    return newNode;
+  }
+  /**
+   * `insertNodeAfter` inserts a node after the given prev node.
+   */
+  static insertNodeAfter(prev, newNode) {
     const prevNext = prev.next;
     prev.next = newNode;
     newNode.prev = prev;
@@ -7299,26 +7341,41 @@ class RGATreeListNode extends SplayNode {
     if (prevNext) {
       prevNext.prev = newNode;
     }
-    return newNode;
   }
   /**
-   * `remove` removes value based on removing time.
+   * `remove` removes the element based on removing time.
    */
   remove(removedAt) {
-    return this.value.remove(removedAt);
+    if (!this._elementEntry) {
+      return false;
+    }
+    return this._elementEntry.elem.remove(removedAt);
   }
   /**
-   * `getCreatedAt` returns creation time of this value
+   * `getCreatedAt` returns the creation time. For live nodes with
+   * elements, returns the element's createdAt for backward
+   * compatibility.
    */
   getCreatedAt() {
-    return this.value.getCreatedAt();
+    if (this._elementEntry) {
+      return this._elementEntry.elem.getCreatedAt();
+    }
+    return this._createdAt;
   }
   /**
-   * `getPositionedAt` returns the time of this element when it was positioned
-   * in the array.
+   * `getPositionedAt` returns the time this element was positioned.
+   * For live nodes, the position register (posMovedAt) is the source
+   * of truth. For dead nodes (no element), the position node's own
+   * createdAt is used.
    */
   getPositionedAt() {
-    return this.value.getPositionedAt();
+    if (this._elementEntry) {
+      if (this._elementEntry.posMovedAt) {
+        return this._elementEntry.posMovedAt;
+      }
+      return this._elementEntry.elem.getCreatedAt();
+    }
+    return this._createdAt;
   }
   /**
    * `release` releases prev and next node.
@@ -7335,9 +7392,13 @@ class RGATreeListNode extends SplayNode {
   }
   /**
    * `getLength` returns the length of this node.
+   * Dead nodes (no element) return 0, removed elements return 0.
    */
   getLength() {
-    return this.value.isRemoved() ? 0 : 1;
+    if (!this._elementEntry || this.isRemoved()) {
+      return 0;
+    }
+    return 1;
   }
   /**
    * `getPrev` returns a previous node.
@@ -7352,28 +7413,87 @@ class RGATreeListNode extends SplayNode {
     return this.next;
   }
   /**
-   * `getMovedFrom` returns the previous element before the element moved.
+   * `getValue` returns the element value.
    */
-  getMovedFrom() {
-    return this.movedFrom;
+  getValue() {
+    if (!this._elementEntry) {
+      return this.value;
+    }
+    return this._elementEntry.elem;
   }
   /**
-   * `setMovedFrom` sets the previous element before the element moved.
+   * `getElement` returns the element or undefined if dead position.
    */
-  setMovedFrom(movedFrom) {
-    this.movedFrom = movedFrom;
+  getElement() {
+    return this._elementEntry?.elem;
   }
   /**
-   * `getValue` returns a element value.
+   * `isRemoved` checks if the value was removed.
    */
-  getValue() {
-    return this.value;
+  isRemoved() {
+    if (!this._elementEntry) {
+      return true;
+    }
+    return this._elementEntry.elem.isRemoved();
   }
   /**
-   * `isRemoved` checks if the value was removed.
+   * `getElementEntry` returns the element entry.
    */
-  isRemoved() {
-    return this.value.isRemoved();
+  getElementEntry() {
+    return this._elementEntry;
+  }
+  /**
+   * `setElementEntry` sets the element entry.
+   */
+  setElementEntry(entry) {
+    this._elementEntry = entry;
+  }
+  /**
+   * `getPositionCreatedAt` returns the position node's own createdAt.
+   */
+  getPositionCreatedAt() {
+    return this._createdAt;
+  }
+  /**
+   * `getPositionMovedAt` returns the LWW timestamp of the element's
+   * move into this position. Undefined for insert-created positions.
+   */
+  getPositionMovedAt() {
+    if (!this._elementEntry) {
+      return void 0;
+    }
+    return this._elementEntry.posMovedAt;
+  }
+  /**
+   * `getRemovedAt` returns the time this dead position node was
+   * removed (for GC).
+   */
+  getRemovedAt() {
+    return this._removedAt;
+  }
+  /**
+   * `setRemovedAt` sets the removal time of this position node.
+   */
+  setRemovedAt(removedAt) {
+    this._removedAt = removedAt;
+  }
+  /**
+   * `toIDString` returns a unique identifier for this position node
+   * (for GC).
+   */
+  toIDString() {
+    return this._createdAt.toIDString();
+  }
+  /**
+   * `getDataSize` returns the data size of this position node
+   * (for GC).
+   */
+  getDataSize() {
+    let meta = TimeTicketSize;
+    if (this._removedAt) {
+      meta += TimeTicketSize;
+    }
+    return { data: 0, meta };
   }
 }
 class RGATreeList {
@@ -7381,13 +7501,15 @@ class RGATreeList {
   last;
   nodeMapByIndex;
   nodeMapByCreatedAt;
+  elementMapByCreatedAt;
   constructor() {
     const dummyValue = Primitive.of(0, InitialTimeTicket);
     dummyValue.setRemovedAt(InitialTimeTicket);
-    this.dummyHead = new RGATreeListNode(dummyValue);
+    this.dummyHead = RGATreeListNode.createWithElement(dummyValue);
     this.last = this.dummyHead;
     this.nodeMapByIndex = new SplayTree();
     this.nodeMapByCreatedAt = /* @__PURE__ */ new Map();
+    this.elementMapByCreatedAt = /* @__PURE__ */ new Map();
     this.nodeMapByIndex.insert(this.dummyHead);
     this.nodeMapByCreatedAt.set(
       this.dummyHead.getCreatedAt().toIDString(),
@@ -7407,22 +7529,10 @@ class RGATreeList {
     return this.nodeMapByIndex.length;
   }
   /**
-   * `findNextBeforeExecutedAt` returns the node by the given createdAt and
-   * executedAt. It passes through nodes created after executedAt from the
-   * given node and returns the next node.
-   * @returns the next node of the given createdAt and executedAt
+   * `findNextBeforeExecutedAt` walks forward from the given node,
+   * skipping nodes positioned after executedAt (RGA insertion rule).
    */
-  findNextBeforeExecutedAt(createdAt, executedAt) {
-    let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-    if (!node) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        `cant find the given node: ${createdAt.toIDString()}`
-      );
-    }
-    while (node.getValue().getMovedAt() && node.getValue().getMovedAt().after(executedAt) && node.getMovedFrom()) {
-      node = node.getMovedFrom();
-    }
+  findNextBeforeExecutedAt(node, executedAt) {
     while (node.getNext() && node.getNext().getPositionedAt().after(executedAt)) {
       node = node.getNext();
     }
@@ -7434,65 +7544,103 @@ class RGATreeList {
     }
     node.release();
     this.nodeMapByIndex.delete(node);
-    this.nodeMapByCreatedAt.delete(node.getValue().getCreatedAt().toIDString());
+    this.nodeMapByCreatedAt.delete(node.getPositionCreatedAt().toIDString());
   }
   /**
-   * `insertAfter` adds a new node with the value after the given node.
+   * `insertAfter` adds a new node with the value after the given
+   * position. prevCreatedAt is a position node identity. Looks up
+   * nodeMapByCreatedAt first, then elementMapByCreatedAt for backward
+   * compatibility.
    */
   insertAfter(prevCreatedAt, value, executedAt = value.getCreatedAt()) {
-    const prevNode = this.findNextBeforeExecutedAt(prevCreatedAt, executedAt);
+    let startNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
+    if (!startNode) {
+      const entry = this.elementMapByCreatedAt.get(prevCreatedAt.toIDString());
+      if (entry) {
+        startNode = entry.positionNode;
+      }
+    }
+    if (!startNode) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `cant find the given node: ${prevCreatedAt.toIDString()}`
+      );
+    }
+    const prevNode = this.findNextBeforeExecutedAt(startNode, executedAt);
     const newNode = RGATreeListNode.createAfter(prevNode, value);
     if (prevNode === this.last) {
       this.last = newNode;
     }
     this.nodeMapByIndex.insertAfter(prevNode, newNode);
-    this.nodeMapByCreatedAt.set(newNode.getCreatedAt().toIDString(), newNode);
+    this.nodeMapByCreatedAt.set(value.getCreatedAt().toIDString(), newNode);
+    this.elementMapByCreatedAt.set(
+      value.getCreatedAt().toIDString(),
+      newNode.getElementEntry()
+    );
     return newNode;
   }
   /**
-   * `moveAfter` moves the given `createdAt` element
-   * after the `prevCreatedAt` element.
+   * `insertPositionAfter` creates a bare position node after
+   * resolving position via forward skip (RGA insertion rule).
+   * Used by moveAfter. prevCreatedAt is a POSITION node identity.
+   */
+  insertPositionAfter(prevCreatedAt, executedAt) {
+    const startNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
+    if (!startNode) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `cant find the given node: ${prevCreatedAt.toIDString()}`
+      );
+    }
+    const prevNode = this.findNextBeforeExecutedAt(startNode, executedAt);
+    const newNode = RGATreeListNode.createBarePosition(executedAt);
+    RGATreeListNode.insertNodeAfter(prevNode, newNode);
+    if (prevNode === this.last) {
+      this.last = newNode;
+    }
+    this.nodeMapByIndex.insertAfter(prevNode, newNode);
+    this.nodeMapByCreatedAt.set(executedAt.toIDString(), newNode);
+    return newNode;
+  }
+  /**
+   * `moveAfter` moves the given `createdAt` element after the
+   * `prevCreatedAt` element using LWW position register semantics.
+   * Returns the dead position node (if any) for GC registration.
    */
   moveAfter(prevCreatedAt, createdAt, executedAt) {
-    let prevNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
-    if (!prevNode) {
+    if (!this.nodeMapByCreatedAt.has(prevCreatedAt.toIDString())) {
       throw new YorkieError(
         Code.ErrInvalidArgument,
         `cant find the given node: ${prevCreatedAt.toIDString()}`
       );
     }
-    let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-    if (!node) {
+    const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+    if (!entry) {
       throw new YorkieError(
         Code.ErrInvalidArgument,
         `cant find the given node: ${createdAt.toIDString()}`
       );
     }
-    if (prevNode !== node && executedAt.after(node.getPositionedAt())) {
-      const movedFrom = node.getPrev();
-      let nextNode = node.getNext();
-      this.release(node);
-      node = this.insertAfter(
-        prevNode.getCreatedAt(),
-        node.getValue(),
-        executedAt
-      );
-      node.getValue().setMovedAt(executedAt);
-      node.setMovedFrom(movedFrom);
-      while (nextNode && nextNode.getPositionedAt().after(executedAt)) {
-        prevNode = node;
-        node = nextNode;
-        nextNode = node.getNext();
-        this.release(node);
-        node = this.insertAfter(
-          prevNode.getCreatedAt(),
-          node.getValue(),
-          executedAt
-        );
-        node.getValue().setMovedAt(executedAt);
-        node.setMovedFrom(movedFrom);
+    if (entry.posMovedAt && !executedAt.after(entry.posMovedAt)) {
+      if (this.nodeMapByCreatedAt.has(executedAt.toIDString())) {
+        return void 0;
       }
+      const deadPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
+      deadPosNode.setRemovedAt(executedAt);
+      this.nodeMapByIndex.splayNode(deadPosNode);
+      return deadPosNode;
     }
+    const newPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
+    const oldPosNode = entry.positionNode;
+    oldPosNode.setElementEntry(void 0);
+    oldPosNode.setRemovedAt(executedAt);
+    this.nodeMapByIndex.splayNode(oldPosNode);
+    newPosNode.setElementEntry(entry);
+    entry.positionNode = newPosNode;
+    entry.posMovedAt = executedAt;
+    entry.elem.setMovedAt(executedAt);
+    this.nodeMapByIndex.splayNode(newPosNode);
+    return oldPosNode;
   }
   /**
    * `insert` adds the given element after the last node.
@@ -7501,34 +7649,53 @@ class RGATreeList {
     this.insertAfter(this.last.getCreatedAt(), value);
   }
   /**
-   * `getByID` returns the element of the given creation time.
+   * `getByID` returns the node of the given creation time.
+   * Checks elementMapByCreatedAt first (for moved elements whose
+   * position node createdAt differs), then nodeMapByCreatedAt.
    */
   getByID(createdAt) {
+    const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+    if (entry) {
+      return entry.positionNode;
+    }
     return this.nodeMapByCreatedAt.get(createdAt.toIDString());
   }
   /**
    * `subPathOf` returns the sub path of the given element.
    */
   subPathOf(createdAt) {
-    const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-    if (!node) {
-      return;
+    const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+    if (!entry) {
+      const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+      if (!node) {
+        return;
+      }
+      return String(this.nodeMapByIndex.indexOf(node));
     }
-    return String(this.nodeMapByIndex.indexOf(node));
+    return String(this.nodeMapByIndex.indexOf(entry.positionNode));
   }
   /**
-   * `purge` physically purges element.
+   * `purge` physically purges the given child. Handles both dead
+   * position nodes (GCChild from GCParent path) and CRDTElements
+   * (from CRDTContainer path).
    */
-  purge(element) {
-    const node = this.nodeMapByCreatedAt.get(
+  purge(child) {
+    if (child instanceof RGATreeListNode) {
+      this.release(child);
+      return;
+    }
+    const element = child;
+    const entry = this.elementMapByCreatedAt.get(
       element.getCreatedAt().toIDString()
     );
-    if (!node) {
+    if (!entry) {
       throw new YorkieError(
         Code.ErrInvalidArgument,
         `fail to find the given createdAt: ${element.getCreatedAt().toIDString()}`
       );
     }
+    const node = entry.positionNode;
+    this.elementMapByCreatedAt.delete(element.getCreatedAt().toIDString());
     this.release(node);
   }
   /**
@@ -7539,42 +7706,69 @@ class RGATreeList {
       return;
     }
     const node = this.nodeMapByIndex.findForArray(idx);
-    const rgaNode = node;
-    return rgaNode;
+    return node;
   }
   /**
-   * `getPrevCreatedAt` returns a creation time of the previous node.
+   * `findPrevCreatedAt` returns the position node's createdAt of the
+   * previous element. This returns a position identity suitable for
+   * use as prevCreatedAt in moveAfter.
    */
-  getPrevCreatedAt(createdAt) {
-    let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+  findPrevCreatedAt(createdAt) {
+    const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+    if (!entry) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `cant find the given node: ${createdAt.toIDString()}`
+      );
+    }
+    let node = entry.positionNode;
     do {
       node = node.getPrev();
-    } while (this.dummyHead !== node && node.isRemoved());
-    return node.getValue().getCreatedAt();
+      if (!node.getElementEntry()) {
+        continue;
+      }
+      if (this.dummyHead === node || !node.isRemoved()) {
+        break;
+      }
+    } while (node);
+    return node.getPositionCreatedAt();
+  }
+  /**
+   * `getPrevCreatedAt` returns the position node's createdAt of the
+   * previous element. Delegates to findPrevCreatedAt.
+   */
+  getPrevCreatedAt(createdAt) {
+    return this.findPrevCreatedAt(createdAt);
   }
   /**
    * `delete` deletes the node of the given creation time.
    */
   delete(createdAt, editedAt) {
-    const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+    const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+    if (!entry) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `cant find the given node: ${createdAt.toIDString()}`
+      );
+    }
+    const node = entry.positionNode;
     const alreadyRemoved = node.isRemoved();
-    if (node.remove(editedAt) && !alreadyRemoved) {
+    if (entry.elem.remove(editedAt) && !alreadyRemoved) {
       this.nodeMapByIndex.splayNode(node);
     }
-    return node.getValue();
+    return entry.elem;
   }
   /**
    * `set` sets the given element at the given creation time.
    */
   set(createdAt, element, executedAt) {
-    const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-    if (!node) {
+    if (!this.elementMapByCreatedAt.has(createdAt.toIDString())) {
       throw new YorkieError(
         Code.ErrInvalidArgument,
         `cant find the given node: ${createdAt.toIDString()}`
       );
     }
-    this.insertAfter(node.getCreatedAt(), element, executedAt);
+    this.insertAfter(createdAt, element, executedAt);
     return this.delete(createdAt, executedAt);
   }
   /**
@@ -7603,18 +7797,80 @@ class RGATreeList {
     return this.last.getValue();
   }
   /**
-   * `getLastCreatedAt` returns the creation time of last element.
+   * `getLastCreatedAt` returns the position node's createdAt of the
+   * last node in the linked list. This is a position identity
+   * suitable for use as prevCreatedAt.
    */
   getLastCreatedAt() {
-    return this.last.getCreatedAt();
+    return this.last.getPositionCreatedAt();
   }
   /**
-   * `toTestString` returns a String containing the meta data of the node id
-   * for debugging purpose.
+   * `posCreatedAt` returns the createdAt of the position node
+   * currently holding the element. Used to convert element identity
+   * to position identity.
+   */
+  posCreatedAt(elemCreatedAt) {
+    const entry = this.elementMapByCreatedAt.get(elemCreatedAt.toIDString());
+    if (!entry) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `cant find the given node: ${elemCreatedAt.toIDString()}`
+      );
+    }
+    return entry.positionNode.getPositionCreatedAt();
+  }
+  /**
+   * `addDeadPosition` appends a dead position node during snapshot
+   * restoration.
+   */
+  addDeadPosition(posCreatedAt, removedAt) {
+    const node = RGATreeListNode.createBarePosition(posCreatedAt);
+    node.setRemovedAt(removedAt);
+    const prevNode = this.last;
+    RGATreeListNode.insertNodeAfter(prevNode, node);
+    this.last = node;
+    this.nodeMapByIndex.insertAfter(prevNode, node);
+    this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
+  }
+  /**
+   * `addMovedElement` appends an element with explicit position
+   * identity during snapshot restoration.
+   */
+  addMovedElement(elem, posCreatedAt, posMovedAt) {
+    const entry = new ElementEntry(elem);
+    entry.posMovedAt = posMovedAt;
+    const node = RGATreeListNode.createBarePosition(posCreatedAt);
+    node.setElementEntry(entry);
+    entry.positionNode = node;
+    const prevNode = this.last;
+    RGATreeListNode.insertNodeAfter(prevNode, node);
+    this.last = node;
+    this.nodeMapByIndex.insertAfter(prevNode, node);
+    this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
+    this.elementMapByCreatedAt.set(elem.getCreatedAt().toIDString(), entry);
+  }
+  /**
+   * `allNodes` returns all nodes including dead position nodes.
+   */
+  allNodes() {
+    const nodes = [];
+    let current = this.dummyHead.getNext();
+    while (current) {
+      nodes.push(current);
+      current = current.getNext();
+    }
+    return nodes;
+  }
+  /**
+   * `toTestString` returns a String containing the meta data of the
+   * node id for debugging purpose.
    */
   toTestString() {
     const json = [];
     for (const node of this) {
+      if (!node.getElementEntry()) {
+        continue;
+      }
       const elem = `${node.getCreatedAt().toIDString()}:${node.getValue().toJSON()}`;
       if (node.isRemoved()) {
         json.push(`{${elem}}`);
@@ -7671,10 +7927,11 @@ class CRDTArray extends CRDTContainer {
     this.elements.insertAfter(prevCreatedAt, value, executedAt);
   }
   /**
-   * `moveAfter` moves the given `createdAt` element after the `prevCreatedAt`.
+   * `moveAfter` moves the given `createdAt` element after the
+   * `prevCreatedAt`. Returns the dead position node for GC.
    */
   moveAfter(prevCreatedAt, createdAt, executedAt) {
-    this.elements.moveAfter(prevCreatedAt, createdAt, executedAt);
+    return this.elements.moveAfter(prevCreatedAt, createdAt, executedAt);
   }
   /**
    * `get` returns the element of the given index.
@@ -7703,11 +7960,20 @@ class CRDTArray extends CRDTContainer {
     return this.elements.getLast();
   }
   /**
-   * `getPrevCreatedAt` returns the creation time of the previous node.
+   * `getPrevCreatedAt` returns the creation time of the previous
+   * node.
    */
   getPrevCreatedAt(createdAt) {
     return this.elements.getPrevCreatedAt(createdAt);
   }
+  /**
+   * `posCreatedAt` returns the createdAt of the position node
+   * currently holding the element. Used to convert element identity
+   * to position identity for moves.
+   */
+  posCreatedAt(elemCreatedAt) {
+    return this.elements.posCreatedAt(elemCreatedAt);
+  }
   /**
    * `delete` deletes the element of the given creation time.
    */
@@ -7721,7 +7987,8 @@ class CRDTArray extends CRDTContainer {
     return this.elements.deleteByIndex(index, editedAt);
   }
   /**
-   * `set` sets the given element at the given position of the creation time.
+   * `set` sets the given element at the given position of the
+   * creation time.
    */
   set(createdAt, value, executedAt) {
     return this.elements.set(createdAt, value, executedAt);
@@ -7739,18 +8006,19 @@ class CRDTArray extends CRDTContainer {
     return this.elements.length;
   }
   /**
-   * `[Symbol.iterator]` returns an iterator for the elements in this array.
+   * `[Symbol.iterator]` returns an iterator for the elements in
+   * this array.
    */
   *[Symbol.iterator]() {
     for (const node of this.elements) {
-      if (!node.isRemoved()) {
+      if (node.getElementEntry() && !node.isRemoved()) {
         yield node.getValue();
       }
     }
   }
   /**
-   * `toTestString` returns a String containing the meta data of this value
-   * for debugging purpose.
+   * `toTestString` returns a String containing the meta data of
+   * this value for debugging purpose.
    */
   toTestString() {
     return this.elements.toTestString();
@@ -7760,6 +8028,9 @@ class CRDTArray extends CRDTContainer {
    */
   getDescendants(callback) {
     for (const node of this.elements) {
+      if (!node.getElementEntry()) {
+        continue;
+      }
       const element = node.getValue();
       if (callback(element, this)) {
         return;
@@ -7821,21 +8092,52 @@ class CRDTArray extends CRDTContainer {
     return this.toJSON();
   }
   /**
-   * `getElements` returns an array of elements contained in this RGATreeList.
+   * `getElements` returns the underlying RGATreeList.
    */
   getElements() {
     return this.elements;
   }
+  /**
+   * `getRGATreeList` returns the underlying RGATreeList (GCParent
+   * for dead positions).
+   */
+  getRGATreeList() {
+    return this.elements;
+  }
+  /**
+   * `getAllRGANodes` returns all RGA nodes including dead position
+   * nodes.
+   */
+  getAllRGANodes() {
+    return this.elements.allNodes();
+  }
   /**
    * `deepcopy` copies itself deeply.
    */
   deepcopy() {
     const clone = CRDTArray.create(this.getCreatedAt());
     for (const node of this.elements) {
-      clone.elements.insertAfter(
-        clone.getLastCreatedAt(),
-        node.getValue().deepcopy()
-      );
+      if (!node.getElementEntry()) {
+        const removedAt = node.getRemovedAt();
+        if (removedAt) {
+          clone.elements.addDeadPosition(
+            node.getPositionCreatedAt(),
+            removedAt
+          );
+        }
+        continue;
+      }
+      const value = node.getValue().deepcopy();
+      const posMovedAt = node.getPositionMovedAt();
+      if (posMovedAt) {
+        clone.elements.addMovedElement(
+          value,
+          node.getPositionCreatedAt(),
+          posMovedAt
+        );
+      } else {
+        clone.elements.insertAfter(clone.getLastCreatedAt(), value);
+      }
     }
     clone.setRemovedAt(this.getRemovedAt());
     clone.setMovedAt(this.getMovedAt());
@@ -8092,6 +8394,9 @@ class SetOperation extends Operation {
     if (removed) {
       root.registerRemovedElement(removed);
     }
+    if (value.getRemovedAt()) {
+      root.registerRemovedElement(value);
+    }
     return {
       opInfos: [
         {
@@ -8184,7 +8489,17 @@ class MoveOperation extends Operation {
     const array = parentObject;
     const reverseOp = this.toReverseOperation(array);
     const previousIndex = Number(array.subPathOf(this.createdAt));
-    array.moveAfter(this.prevCreatedAt, this.createdAt, this.getExecutedAt());
+    const deadNode = array.moveAfter(
+      this.prevCreatedAt,
+      this.createdAt,
+      this.getExecutedAt()
+    );
+    if (deadNode) {
+      root.registerGCPair({
+        parent: array.getRGATreeList(),
+        child: deadNode
+      });
+    }
     const index = Number(array.subPathOf(this.createdAt));
     return {
       opInfos: [
@@ -8207,7 +8522,8 @@ class MoveOperation extends Operation {
     );
   }
   /**
-   * `getEffectedCreatedAt` returns the creation time of the effected element.
+   * `getEffectedCreatedAt` returns the creation time of the
+   * effected element.
    */
   getEffectedCreatedAt() {
     return this.createdAt;
@@ -8219,7 +8535,8 @@ class MoveOperation extends Operation {
     return `${this.getParentCreatedAt().toTestString()}.MOVE`;
   }
   /**
-   * `getPrevCreatedAt` returns the creation time of previous element.
+   * `getPrevCreatedAt` returns the creation time of previous
+   * element.
    */
   getPrevCreatedAt() {
     return this.prevCreatedAt;
@@ -8231,7 +8548,8 @@ class MoveOperation extends Operation {
     return this.createdAt;
   }
   /**
-   * `setPrevCreatedAt` sets the creation time of the previous element.
+   * `setPrevCreatedAt` sets the creation time of the previous
+   * element.
    */
   setPrevCreatedAt(createdAt) {
     this.prevCreatedAt = createdAt;
@@ -10812,6 +11130,32 @@ class IndexTreeNode {
       }
       actualRight.push(child);
     }
+    if (versionVector) {
+      const movedToLeft = [];
+      const remaining = [];
+      let boundaryReached = false;
+      for (const child of actualRight) {
+        if (!boundaryReached) {
+          if (child.insPrevID !== void 0 && !child.isText) {
+            remaining.push(child);
+            continue;
+          }
+          const actorID = child.id.getCreatedAt().getActorID();
+          const knownLamport = versionVector.get(actorID);
+          if (knownLamport === void 0 || knownLamport < child.id.getCreatedAt().getLamport()) {
+            movedToLeft.push(child);
+            continue;
+          }
+        }
+        boundaryReached = true;
+        remaining.push(child);
+      }
+      if (movedToLeft.length > 0) {
+        left.push(...movedToLeft);
+        actualRight.length = 0;
+        actualRight.push(...remaining);
+      }
+    }
     this._children = left;
     clone._children = actualRight;
     this.visibleSize = this._children.reduce(
@@ -11575,7 +11919,7 @@ class CRDTTreeNode extends IndexTreeNode {
       CRDTTreeNodeID.of(issueTimeTicket(), 0),
       this.type,
       void 0,
-      void 0,
+      this.attrs?.deepcopy(),
       this.removedAt
     );
   }
@@ -11588,8 +11932,14 @@ class CRDTTreeNode extends IndexTreeNode {
       split.insPrevID = this.id;
       if (this.insNextID) {
         const insNext = tree.findFloorNode(this.insNextID);
-        insNext.insPrevID = split.id;
         split.insNextID = this.insNextID;
+        if (insNext) {
+          insNext.insPrevID = split.id;
+          if (!this.isText && insNext.parent && !insNext.isRemoved && insNext.parent !== split.parent && split.allChildren.length === 0) {
+            split.parent.detachChild(split);
+            insNext.parent.insertBefore(split, insNext);
+          }
+        }
       }
       this.insNextID = split.id;
       tree.registerNode(split);
@@ -11813,7 +12163,7 @@ class CRDTTree extends CRDTElement {
    * given node, advancing past element-type split siblings that the editing
    * client did not know about (not in versionVector).
    */
-  advancePastUnknownSplitSiblings(node, versionVector) {
+  advancePastUnknownSplitSiblings(node, versionVector, relaxParentCheck = false, skipActorID) {
     if (!versionVector || !node) {
       return node;
     }
@@ -11823,10 +12173,13 @@ class CRDTTree extends CRDTElement {
       if (!next || next.isText) {
         break;
       }
-      if (next.parent !== current.parent) {
+      if (!relaxParentCheck && next.parent !== current.parent) {
         break;
       }
       const actorID = next.id.getCreatedAt().getActorID();
+      if (skipActorID !== void 0 && actorID === skipActorID) {
+        break;
+      }
       const knownLamport = versionVector.get(actorID);
       if (knownLamport !== void 0 && knownLamport >= next.id.getCreatedAt().getLamport()) {
         break;
@@ -11995,6 +12348,53 @@ class CRDTTree extends CRDTElement {
               addDataSizes(diff, curr.getDataSize());
             }
           }
+          if (tokenType === TokenType.Start && versionVector !== void 0) {
+            let current = node;
+            while (current.insNextID) {
+              const next = this.findFloorNode(current.insNextID);
+              if (!next || next.isText) {
+                break;
+              }
+              if (ticketKnown(versionVector, next.id.getCreatedAt())) {
+                break;
+              }
+              const siblingPairs = next.setAttrs(attributes, editedAt);
+              const siblingAffectedAttrs = siblingPairs.reduce(
+                (acc, [, curr]) => {
+                  if (curr) {
+                    acc[curr.getKey()] = attrs[curr.getKey()];
+                  }
+                  return acc;
+                },
+                {}
+              );
+              if (Object.keys(siblingAffectedAttrs).length > 0) {
+                const parentOfNext = next.parent;
+                const previousNext = next.prevSibling || parentOfNext;
+                changes.push({
+                  type: "style",
+                  from: this.toIndex(parentOfNext, previousNext),
+                  to: this.toIndex(next, next),
+                  fromPath: this.toPath(parentOfNext, previousNext),
+                  toPath: this.toPath(next, next),
+                  actor: editedAt.getActorID(),
+                  value: siblingAffectedAttrs
+                });
+              }
+              for (const [prev] of siblingPairs) {
+                if (prev) {
+                  pairs.push({ parent: next, child: prev });
+                }
+              }
+              for (const [key] of Object.entries(attrs)) {
+                const curr = next.attrs?.getNodeMapByKey().get(key);
+                if (curr !== void 0) {
+                  addDataSizes(diff, curr.getDataSize());
+                }
+              }
+              current = next;
+            }
+          }
         }
       }
     );
@@ -12061,6 +12461,43 @@ class CRDTTree extends CRDTElement {
             toPath: this.toPath(node, node),
             value: attributesToRemove
           });
+          if (tokenType === TokenType.Start && versionVector !== void 0) {
+            let current = node;
+            while (current.insNextID) {
+              const next = this.findFloorNode(current.insNextID);
+              if (!next || next.isText) {
+                break;
+              }
+              if (ticketKnown(versionVector, next.id.getCreatedAt())) {
+                break;
+              }
+              if (!next.attrs) {
+                next.attrs = new RHT();
+              }
+              let removedAny = false;
+              for (const value of attributesToRemove) {
+                const nodesTobeRemoved = next.attrs.remove(value, editedAt);
+                removedAny = removedAny || nodesTobeRemoved.length > 0;
+                for (const rhtNode of nodesTobeRemoved) {
+                  pairs.push({ parent: next, child: rhtNode });
+                }
+              }
+              if (removedAny) {
+                const parentOfNext = next.parent;
+                const previousNext = next.prevSibling || parentOfNext;
+                changes.push({
+                  actor: editedAt.getActorID(),
+                  type: "removeStyle",
+                  from: this.toIndex(parentOfNext, previousNext),
+                  to: this.toIndex(next, next),
+                  fromPath: this.toPath(parentOfNext, previousNext),
+                  toPath: this.toPath(next, next),
+                  value: attributesToRemove
+                });
+              }
+              current = next;
+            }
+          }
         }
       }
     );
@@ -12083,6 +12520,23 @@ class CRDTTree extends CRDTElement {
     addDataSizes(diff, diffTo, diffFrom);
     const fromLeft = fromLeftRaw !== fromParent ? this.advancePastUnknownSplitSiblings(fromLeftRaw, versionVector) : fromLeftRaw;
     const toLeft = toLeftRaw !== toParent ? this.advancePastUnknownSplitSiblings(toLeftRaw, versionVector) : toLeftRaw;
+    let collectFromParent = fromParent;
+    let collectFromLeft = fromLeft;
+    if (fromLeft !== fromParent && fromParent !== toParent) {
+      let current = fromLeft;
+      while (current.insNextID) {
+        const next = this.findFloorNode(current.insNextID);
+        if (!next || next.isText) {
+          break;
+        }
+        if (next.parent && next.parent === toParent) {
+          collectFromLeft = next;
+          collectFromParent = toParent;
+          break;
+        }
+        current = next;
+      }
+    }
     const fromIdx = this.toIndex(fromParent, fromLeft);
     const fromPath = this.toPath(fromParent, fromLeft);
     const nodesToBeRemoved = [];
@@ -12091,8 +12545,8 @@ class CRDTTree extends CRDTElement {
     const toBeMergedNodes = [];
     const preTombstoned = /* @__PURE__ */ new Set();
     this.traverseInPosRange(
-      fromParent,
-      fromLeft,
+      collectFromParent,
+      collectFromLeft,
       toParent,
       toLeft,
       ([node, tokenType], ended) => {
@@ -12196,9 +12650,20 @@ class CRDTTree extends CRDTElement {
       let parent = fromParent;
       let left = fromLeft;
       while (splitCount < splitLevel) {
+        if (left !== parent) {
+          left = this.advancePastUnknownSplitSiblings(
+            left,
+            versionVector,
+            true,
+            editedAt.getActorID()
+          );
+          if (left.parent && left.parent !== parent) {
+            parent = left.parent;
+          }
+        }
         parent.split(
           this,
-          parent.findOffset(left, true) + 1,
+          left !== parent ? parent.findOffset(left, true) + 1 : 0,
           issueTimeTicket,
           versionVector
         );
@@ -12805,10 +13270,10 @@ class TreeEditOperation extends Operation {
     );
     this.lastToIdx = preEditFromIdx + removedSize;
     let reverseOp;
-    const isPureL1Split = this.splitLevel === 1 && !this.contents?.length && removedNodes.length === 0;
+    const isPureSplit = this.splitLevel > 0 && !this.contents?.length && removedNodes.length === 0;
     if (this.splitLevel === 0) {
       reverseOp = this.toReverseOperation(tree, removedNodes, preEditFromIdx);
-    } else if (isPureL1Split) {
+    } else if (isPureSplit) {
       reverseOp = this.toSplitReverseOperation(tree, preEditFromIdx);
     }
     root.acc(diff);
@@ -14819,14 +15284,26 @@ function toRHTNodes(rht) {
   }
   return pbRHTNodes;
 }
-function toRGANodes(rgaTreeList) {
+function toRGANodes(arr) {
   const pbRGANodes = [];
-  for (const rgaTreeListNode of rgaTreeList) {
-    pbRGANodes.push(
-      create(RGANodeSchema, {
-        element: toElement(rgaTreeListNode.getValue())
-      })
-    );
+  for (const rgaNode of arr.getAllRGANodes()) {
+    if (!rgaNode.getElementEntry()) {
+      pbRGANodes.push(
+        create(RGANodeSchema, {
+          positionCreatedAt: toTimeTicket(rgaNode.getPositionCreatedAt()),
+          positionRemovedAt: toTimeTicket(rgaNode.getRemovedAt())
+        })
+      );
+      continue;
+    }
+    const pbNode = create(RGANodeSchema, {
+      element: toElement(rgaNode.getValue())
+    });
+    if (rgaNode.getPositionMovedAt()) {
+      pbNode.positionMovedAt = toTimeTicket(rgaNode.getPositionMovedAt());
+      pbNode.positionCreatedAt = toTimeTicket(rgaNode.getPositionCreatedAt());
+    }
+    pbRGANodes.push(pbNode);
   }
   return pbRGANodes;
 }
@@ -14926,7 +15403,7 @@ function toArray(arr) {
     body: {
       case: "jsonArray",
       value: create(JSONElement_JSONArraySchema, {
-        nodes: toRGANodes(arr.getElements()),
+        nodes: toRGANodes(arr),
         createdAt: toTimeTicket(arr.getCreatedAt()),
         movedAt: toTimeTicket(arr.getMovedAt()),
         removedAt: toTimeTicket(arr.getRemovedAt())
@@ -15464,7 +15941,32 @@ function fromObject(pbObject) {
 function fromArray(pbArray) {
   const rgaTreeList = new RGATreeList();
   for (const pbRGANode of pbArray.nodes) {
-    rgaTreeList.insert(fromElement(pbRGANode.element));
+    if (!pbRGANode.element) {
+      if (!pbRGANode.positionCreatedAt || !pbRGANode.positionRemovedAt) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          "dead RGA position node missing position timestamps"
+        );
+      }
+      const posCreatedAt = fromTimeTicket(pbRGANode.positionCreatedAt);
+      const posRemovedAt = fromTimeTicket(pbRGANode.positionRemovedAt);
+      rgaTreeList.addDeadPosition(posCreatedAt, posRemovedAt);
+      continue;
+    }
+    const elem = fromElement(pbRGANode.element);
+    const posMovedAt = fromTimeTicket(pbRGANode.positionMovedAt);
+    if (posMovedAt) {
+      if (!pbRGANode.positionCreatedAt) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          "moved RGA node missing position_created_at"
+        );
+      }
+      const posCreatedAt = fromTimeTicket(pbRGANode.positionCreatedAt);
+      rgaTreeList.addMovedElement(elem, posCreatedAt, posMovedAt);
+    } else {
+      rgaTreeList.insert(elem);
+    }
   }
   const arr = new CRDTArray(fromTimeTicket(pbArray.createdAt), rgaTreeList);
   arr.setMovedAt(fromTimeTicket(pbArray.movedAt));
@@ -16252,10 +16754,16 @@ class ArrayProxy {
           };
         } else if (method === "insertAfter") {
           return (prevID, value) => {
+            let posCreatedAt;
+            try {
+              posCreatedAt = target.posCreatedAt(prevID);
+            } catch {
+              posCreatedAt = prevID;
+            }
             const inserted = ArrayProxy.insertAfterInternal(
               context,
               target,
-              prevID,
+              posCreatedAt,
               value
             );
             return toWrappedElement(context, inserted);
@@ -16440,7 +16948,7 @@ class ArrayProxy {
   static moveBeforeInternal(context, target, nextCreatedAt, createdAt) {
     const ticket = context.issueTimeTicket();
     const prevCreatedAt = target.getPrevCreatedAt(nextCreatedAt);
-    target.moveAfter(prevCreatedAt, createdAt, ticket);
+    const deadNode = target.moveAfter(prevCreatedAt, createdAt, ticket);
     context.push(
       MoveOperation.create(
         target.getCreatedAt(),
@@ -16449,26 +16957,45 @@ class ArrayProxy {
         ticket
       )
     );
+    if (deadNode) {
+      context.registerGCPair({
+        parent: target.getRGATreeList(),
+        child: deadNode
+      });
+    }
   }
   /**
    * `moveAfterInternal` moves the given `createdAt` element
-   * after the specific element.
+   * after the specific element. Converts element identity to
+   * position identity for the prevCreatedAt.
    */
   static moveAfterInternal(context, target, prevCreatedAt, createdAt) {
     const ticket = context.issueTimeTicket();
+    let posCreatedAt;
+    try {
+      posCreatedAt = target.posCreatedAt(prevCreatedAt);
+    } catch {
+      posCreatedAt = prevCreatedAt;
+    }
+    const deadNode = target.moveAfter(posCreatedAt, createdAt, ticket);
     context.push(
       MoveOperation.create(
         target.getCreatedAt(),
-        prevCreatedAt,
+        posCreatedAt,
         createdAt,
         ticket
       )
     );
-    target.moveAfter(prevCreatedAt, createdAt, ticket);
+    if (deadNode) {
+      context.registerGCPair({
+        parent: target.getRGATreeList(),
+        child: deadNode
+      });
+    }
   }
   /**
-   * `moveAfterByIndexInternal` moves the given element to its new position
-   * after the given previous element.
+   * `moveAfterByIndexInternal` moves the given element to its new
+   * position after the given previous element.
    */
   static moveAfterByIndexInternal(context, target, prevIndex, targetIndex) {
     const prevElem = target.get(prevIndex);
@@ -16499,7 +17026,7 @@ class ArrayProxy {
   static moveFrontInternal(context, target, createdAt) {
     const ticket = context.issueTimeTicket();
     const head = target.getHead();
-    target.moveAfter(head.getCreatedAt(), createdAt, ticket);
+    const deadNode = target.moveAfter(head.getCreatedAt(), createdAt, ticket);
     context.push(
       MoveOperation.create(
         target.getCreatedAt(),
@@ -16508,6 +17035,12 @@ class ArrayProxy {
         ticket
       )
     );
+    if (deadNode) {
+      context.registerGCPair({
+        parent: target.getRGATreeList(),
+        child: deadNode
+      });
+    }
   }
   /**
    * `moveLastInternal` moves the given `createdAt` element
@@ -16516,13 +17049,20 @@ class ArrayProxy {
   static moveLastInternal(context, target, createdAt) {
     const ticket = context.issueTimeTicket();
     const last = target.getLastCreatedAt();
-    target.moveAfter(last, createdAt, ticket);
+    const deadNode = target.moveAfter(last, createdAt, ticket);
     context.push(
       MoveOperation.create(target.getCreatedAt(), last, createdAt, ticket)
     );
+    if (deadNode) {
+      context.registerGCPair({
+        parent: target.getRGATreeList(),
+        child: deadNode
+      });
+    }
   }
   /**
-   * `insertAfterInternal` inserts the value after the previously created element.
+   * `insertAfterInternal` inserts the value after the previously
+   * created element.
    */
   static insertAfterInternal(context, target, prevCreatedAt, value) {
     const createdAt = context.issueTimeTicket();
@@ -16550,12 +17090,13 @@ class ArrayProxy {
         `index out of bounds: ${index}`
       );
     }
-    ArrayProxy.insertAfterInternal(
-      context,
-      target,
-      prevElem.getCreatedAt(),
-      value
-    );
+    let posCreatedAt;
+    try {
+      posCreatedAt = target.posCreatedAt(prevElem.getCreatedAt());
+    } catch {
+      posCreatedAt = prevElem.getCreatedAt();
+    }
+    ArrayProxy.insertAfterInternal(context, target, posCreatedAt, value);
     return target;
   }
   /**
@@ -16654,7 +17195,17 @@ class ArrayProxy {
       }
     }
     if (items) {
-      let previousID = from === 0 ? target.getHead().getID() : target.get(from - 1).getID();
+      let previousID;
+      if (from === 0) {
+        previousID = target.getHead().getID();
+      } else {
+        const elemID = target.get(from - 1).getID();
+        try {
+          previousID = target.posCreatedAt(elemID);
+        } catch {
+          previousID = elemID;
+        }
+      }
       for (const item of items) {
         const newElem = ArrayProxy.insertAfterInternal(
           context,
@@ -18004,6 +18555,16 @@ class CRDTRoot {
           this.registerGCPair(pair);
         }
       }
+      if (elem instanceof CRDTArray) {
+        for (const node of elem.getAllRGANodes()) {
+          if (!node.getElementEntry() && node.getRemovedAt()) {
+            this.registerGCPair({
+              parent: elem.getRGATreeList(),
+              child: node
+            });
+          }
+        }
+      }
       return false;
     });
   }
@@ -19095,6 +19656,11 @@ class Document {
       if (logger.isEnabled(LogLevel.Trivial)) {
         logger.trivial(`trying to update a local change: ${this.toJSON()}`);
       }
+      const prev = {
+        hadPresence: this.presences.has(actorID),
+        wasOnline: this.status === "attached",
+        presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+      };
       const change = ctx.toChange();
       const { opInfos, reverseOps } = change.execute(
         this.root,
@@ -19140,14 +19706,14 @@ class Document {
         });
       }
       if (change.hasPresenceChange()) {
-        event.push({
-          type: "presence-changed",
-          source: OpSource.Local,
-          value: {
-            clientID: actorID,
-            presence: this.getPresence(actorID)
-          }
-        });
+        const presenceEvent = this.reconcilePresence(
+          actorID,
+          prev,
+          OpSource.Local
+        );
+        if (presenceEvent) {
+          event.push(presenceEvent);
+        }
       }
       this.publish(event);
       if (logger.isEnabled(LogLevel.Trivial)) {
@@ -19631,41 +20197,11 @@ class Document {
     change.execute(this.clone.root, this.clone.presences, source);
     const events = [];
     const actorID = change.getID().getActorID();
-    if (change.hasPresenceChange() && this.onlineClients.has(actorID)) {
-      const presenceChange = change.getPresenceChange();
-      switch (presenceChange.type) {
-        case PresenceChangeType.Put:
-          events.push(
-            this.presences.has(actorID) ? {
-              type: "presence-changed",
-              source,
-              value: {
-                clientID: actorID,
-                presence: presenceChange.presence
-              }
-            } : {
-              type: "watched",
-              source: OpSource.Remote,
-              value: {
-                clientID: actorID,
-                presence: presenceChange.presence
-              }
-            }
-          );
-          break;
-        case PresenceChangeType.Clear:
-          events.push({
-            type: "unwatched",
-            source: OpSource.Remote,
-            value: {
-              clientID: actorID,
-              presence: this.getPresence(actorID)
-            }
-          });
-          this.removeOnlineClient(actorID);
-          break;
-      }
-    }
+    const prev = change.hasPresenceChange() ? {
+      hadPresence: this.presences.has(actorID),
+      wasOnline: this.onlineClients.has(actorID),
+      presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+    } : void 0;
     const { opInfos, operations } = change.execute(
       this.root,
       this.presences,
@@ -19720,6 +20256,16 @@ class Document {
         }
       );
     }
+    if (prev && change.hasPresenceChange()) {
+      const presenceChange = change.getPresenceChange();
+      if (presenceChange.type === PresenceChangeType.Clear) {
+        this.removeOnlineClient(actorID);
+      }
+      const presenceEvent = this.reconcilePresence(actorID, prev, source);
+      if (presenceEvent) {
+        events.push(presenceEvent);
+      }
+    }
     if (events.length) {
       this.publish(events);
     }
@@ -19748,46 +20294,43 @@ class Document {
    * `applyDocEvent` applies the given doc event into this document.
    */
   applyDocEvent(type, publisher) {
-    const events = [];
+    const prev = {
+      hadPresence: this.presences.has(publisher),
+      wasOnline: this.onlineClients.has(publisher),
+      presence: this.presences.has(publisher) ? deepcopy(this.presences.get(publisher)) : void 0
+    };
     if (type === DocEventType$1.DOCUMENT_WATCHED) {
       if (this.onlineClients.has(publisher) && this.hasPresence(publisher)) {
         return;
       }
       this.addOnlineClient(publisher);
-      if (this.hasPresence(publisher)) {
-        events.push({
-          type: "watched",
-          source: OpSource.Remote,
-          value: {
-            clientID: publisher,
-            presence: this.getPresence(publisher)
-          }
-        });
-      }
     } else if (type === DocEventType$1.DOCUMENT_UNWATCHED) {
-      const presence = this.getPresence(publisher);
       this.removeOnlineClient(publisher);
       this.presences.delete(publisher);
-      if (presence) {
-        events.push({
-          type: "unwatched",
-          source: OpSource.Remote,
-          value: { clientID: publisher, presence }
-        });
-      }
     }
-    if (events.length) {
-      this.publish(events);
+    const event = this.reconcilePresence(publisher, prev, OpSource.Remote);
+    if (event) {
+      this.publish([event]);
     }
   }
   /**
    * `applyStatus` applies the document status into this document.
    */
   applyStatus(status) {
+    const actorID = this.changeID.getActorID();
+    const prev = {
+      hadPresence: this.presences.has(actorID),
+      wasOnline: this.status === "attached",
+      presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+    };
     this.status = status;
     if (status === "detached") {
       this.setActor(InitialActorID);
     }
+    const event = this.reconcilePresence(actorID, prev, OpSource.Local);
+    if (event) {
+      this.publish([event]);
+    }
     this.publish([
       {
         source: status === "removed" ? OpSource.Remote : OpSource.Local,
@@ -19887,6 +20430,57 @@ class Document {
   removeOnlineClient(clientID) {
     this.onlineClients.delete(clientID);
   }
+  /**
+   * `reconcilePresence` compares the previous and current state of a client's
+   * presence/online status and returns the appropriate event to emit.
+   *
+   * For remote clients, "online" means the client is in onlineClients.
+   * For self, "online" means the document status is Attached.
+   *
+   * State transition table:
+   *   (!hadP || !wasOn) → (hasP && isOn)  : watched (remote) or presence-changed (self)
+   *   (hadP && wasOn)   → (hasP && isOn)  : presence-changed
+   *   (hadP && wasOn)   → (!hasP || !isOn): unwatched (remote only)
+   *   otherwise                           : no event (waiting)
+   */
+  reconcilePresence(actorID, prev, source) {
+    const isSelf = actorID === this.changeID.getActorID();
+    const hasPresence = this.presences.has(actorID);
+    const isOnline = isSelf ? this.status === "attached" : this.onlineClients.has(actorID);
+    if (!hasPresence || !isOnline) {
+      if (prev.hadPresence && prev.wasOnline && !isSelf) {
+        return {
+          type: "unwatched",
+          source: OpSource.Remote,
+          value: {
+            clientID: actorID,
+            presence: prev.presence
+          }
+        };
+      }
+      return void 0;
+    }
+    const presence = deepcopy(this.presences.get(actorID));
+    if (!prev.hadPresence || !prev.wasOnline) {
+      if (isSelf) {
+        return {
+          type: "presence-changed",
+          source,
+          value: { clientID: actorID, presence }
+        };
+      }
+      return {
+        type: "watched",
+        source: OpSource.Remote,
+        value: { clientID: actorID, presence }
+      };
+    }
+    return {
+      type: "presence-changed",
+      source,
+      value: { clientID: actorID, presence }
+    };
+  }
   /**
    * `hasPresence` returns whether the given clientID has a presence or not.
    */
@@ -20048,18 +20642,24 @@ class Document {
       const ticket = ctx.issueTimeTicket();
       op.setExecutedAt(ticket);
       if (op instanceof ArraySetOperation) {
-        const prev = op.getCreatedAt();
+        const prev2 = op.getCreatedAt();
         op.getValue().setCreatedAt(ticket);
-        this.internalHistory.reconcileCreatedAt(prev, ticket);
+        this.internalHistory.reconcileCreatedAt(prev2, ticket);
       } else if (op instanceof AddOperation) {
-        const prev = op.getValue().getCreatedAt();
+        const prev2 = op.getValue().getCreatedAt();
         op.getValue().setCreatedAt(ticket);
-        this.internalHistory.reconcileCreatedAt(prev, ticket);
+        this.internalHistory.reconcileCreatedAt(prev2, ticket);
       }
       ctx.push(op);
     }
     const change = ctx.toChange();
     change.execute(this.clone.root, this.clone.presences, OpSource.UndoRedo);
+    const actorID = this.changeID.getActorID();
+    const prev = {
+      hadPresence: this.presences.has(actorID),
+      wasOnline: this.status === "attached",
+      presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+    };
     const { opInfos, reverseOps } = change.execute(
       this.root,
       this.presences,
@@ -20081,7 +20681,6 @@ class Document {
     }
     this.localChanges.push(change);
     this.changeID = ctx.getNextID();
-    const actorID = this.changeID.getActorID();
     const events = [];
     if (opInfos.length) {
       events.push({
@@ -20098,14 +20697,14 @@ class Document {
       });
     }
     if (change.hasPresenceChange()) {
-      events.push({
-        type: "presence-changed",
-        source: OpSource.UndoRedo,
-        value: {
-          clientID: actorID,
-          presence: this.getPresence(actorID)
-        }
-      });
+      const presenceEvent = this.reconcilePresence(
+        actorID,
+        prev,
+        OpSource.UndoRedo
+      );
+      if (presenceEvent) {
+        events.push(presenceEvent);
+      }
     }
     this.publish(events);
   }
@@ -20121,6 +20720,8 @@ class Attachment {
   watchStream;
   watchLoopTimerID;
   watchAbortController;
+  syncPromise;
+  _detaching = false;
   constructor(reconnectStreamDelay, resource, resourceID, syncMode) {
     this.reconnectStreamDelay = reconnectStreamDelay;
     this.resource = resource;
@@ -20196,6 +20797,49 @@ class Attachment {
     };
     await doLoop();
   }
+  /**
+   * `markDetaching` marks this attachment as being in the process of detaching.
+   * Once marked, the sync loop will skip this attachment.
+   */
+  markDetaching() {
+    this._detaching = true;
+  }
+  /**
+   * `isDetaching` returns whether this attachment is being detached.
+   */
+  isDetaching() {
+    return this._detaching;
+  }
+  /**
+   * `resetDetaching` resets the detaching flag so the attachment can resume
+   * syncing. Used when a detach RPC fails and the document remains attached.
+   */
+  resetDetaching() {
+    this._detaching = false;
+  }
+  /**
+   * `setSyncPromise` sets the in-progress sync promise for this attachment.
+   */
+  setSyncPromise(promise) {
+    this.syncPromise = promise;
+  }
+  /**
+   * `clearSyncPromise` clears the in-progress sync promise.
+   */
+  clearSyncPromise() {
+    this.syncPromise = void 0;
+  }
+  /**
+   * `waitForSyncComplete` waits for any in-progress sync to complete.
+   */
+  async waitForSyncComplete() {
+    if (this.syncPromise) {
+      try {
+        await this.syncPromise;
+      } catch {
+      }
+    }
+  }
   /**
    * `cancelWatchStream` cancels the watch stream.
    */
@@ -20230,7 +20874,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.7.5";
+const version = "0.7.7";
 const pkg = {
   name,
   version
@@ -20555,6 +21199,7 @@ class Client {
   taskQueue;
   processing = false;
   keepalive = false;
+  deactivating = false;
   /**
    * @param rpcAddr - the address of the RPC server.
    * @param opts - the options of the client.
@@ -20624,6 +21269,7 @@ class Client {
         );
         this.id = res.clientId;
         this.status = "activated";
+        this.deactivating = false;
         this.runSyncLoop();
         logger.info(`[AC] c:"${this.getKey()}" activated, id:"${this.id}"`);
         if (typeof window !== "undefined") {
@@ -20652,6 +21298,7 @@ class Client {
     if (this.status === "deactivated") {
       return Promise.resolve();
     }
+    this.deactivating = true;
     const task = async () => {
       try {
         await this.rpcClient.deactivateClient(
@@ -20665,6 +21312,7 @@ class Client {
         logger.info(`[DC] c"${this.getKey()}" deactivated`);
       } catch (err) {
         logger.error(`[DC] c:"${this.getKey()}" err :`, err);
+        this.deactivating = false;
         await this.handleConnectError(err);
         throw err;
       }
@@ -20805,8 +21453,10 @@ class Client {
       );
     }
     doc.update((_, p) => p.clear());
+    attachment.markDetaching();
     const task = async () => {
       try {
+        await attachment.waitForSyncComplete();
         const res = await this.rpcClient.detachDocument(
           {
             clientId: this.id,
@@ -20825,6 +21475,7 @@ class Client {
         return doc;
       } catch (err) {
         logger.error(`[DD] c:"${this.getKey()}" err :`, err);
+        attachment.resetDetaching();
         await this.handleConnectError(err);
         throw err;
       }
@@ -21391,7 +22042,7 @@ class Client {
    */
   runSyncLoop() {
     const doLoop = async () => {
-      if (!this.isActive()) {
+      if (!this.isActive() || this.deactivating) {
         logger.debug(`[SL] c:"${this.getKey()}" exit sync loop`);
         this.conditions[
           "SyncLoop"
@@ -21403,43 +22054,62 @@ class Client {
         await this.enqueueTask(async () => {
           const syncs = [];
           for (const [, attachment] of this.attachmentMap) {
+            if (this.deactivating) {
+              break;
+            }
             if (!attachment.needSync(this.channelHeartbeatInterval)) {
               continue;
             }
+            if (attachment.isDetaching()) {
+              continue;
+            }
             if (attachment.changeEventReceived !== void 0) {
               attachment.changeEventReceived = false;
             }
-            syncs.push(
-              this.syncInternal(attachment, attachment.syncMode).catch((e) => {
-                if (isErrorCode(e, Code.ErrUnauthenticated)) {
-                  attachment.resource.publish([
-                    {
-                      type: DocEventType.AuthError,
-                      value: {
-                        reason: errorMetadataOf(e).reason,
-                        method: "PushPull"
-                      }
+            const syncPromise = this.syncInternal(
+              attachment,
+              attachment.syncMode
+            ).then(() => {
+            }).catch((e) => {
+              if (isErrorCode(e, Code.ErrUnauthenticated)) {
+                attachment.resource.publish([
+                  {
+                    type: DocEventType.AuthError,
+                    value: {
+                      reason: errorMetadataOf(e).reason,
+                      method: "PushPull"
                     }
-                  ]);
-                }
-                if (isErrorCode(e, Code.ErrEpochMismatch)) {
-                  attachment.resource.publish([
-                    {
-                      type: DocEventType.EpochMismatch,
-                      value: {
-                        method: "PushPull"
-                      }
+                  }
+                ]);
+              }
+              if (isErrorCode(e, Code.ErrEpochMismatch)) {
+                attachment.resource.publish([
+                  {
+                    type: DocEventType.EpochMismatch,
+                    value: {
+                      method: "PushPull"
                     }
-                  ]);
-                }
-                throw e;
-              })
-            );
+                  }
+                ]);
+              }
+              throw e;
+            }).finally(() => {
+              attachment.clearSyncPromise();
+            });
+            attachment.setSyncPromise(syncPromise);
+            syncs.push(syncPromise);
           }
           await Promise.all(syncs);
           setTimeout(doLoop, this.syncLoopDuration);
         });
       } catch (err) {
+        if (this.deactivating) {
+          this.conditions[
+            "SyncLoop"
+            /* SyncLoop */
+          ] = false;
+          return;
+        }
         logger.error(`[SL] c:"${this.getKey()}" sync failed:`, err);
         if (await this.handleConnectError(err)) {
           setTimeout(doLoop, this.retrySyncLoopDelay);
@@ -21920,8 +22590,11 @@ function isBinData(value) {
 function isCounter(value) {
   return typeof value === "object" && value !== null && value.type === "Counter" && typeof value.value === "object";
 }
+function isDedupCounter(value) {
+  return typeof value === "object" && value !== null && value.type === "DedupCounter" && typeof value.value === "object" && typeof value.registers === "string";
+}
 function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value) && !isDedupCounter(value);
 }
 function parse(yson) {
   try {
@@ -21937,6 +22610,12 @@ function parse(yson) {
 }
 function preprocessYSON(yson) {
   let result = yson;
+  result = result.replace(
+    /DedupCounter\(Int\((-?\d+)\),"([^"]+)"\)/g,
+    (_, value, registers) => {
+      return `{"__yson_type":"DedupCounter","__yson_data":{"__yson_type":"Int","__yson_data":${value}},"__yson_registers":"${registers}"}`;
+    }
+  );
   result = result.replace(
     /Counter\((Int|Long)\((-?\d+)\)\)/g,
     (_, type, value) => {
@@ -21997,6 +22676,20 @@ function postprocessValue(value) {
       value: value.__yson_data
     };
   }
+  if (value.__yson_type === "DedupCounter" && typeof value.__yson_data === "object" && typeof value.__yson_registers === "string") {
+    const counterValue = postprocessValue(value.__yson_data);
+    if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && counterValue.type === "Int") {
+      return {
+        type: "DedupCounter",
+        value: counterValue,
+        registers: value.__yson_registers
+      };
+    }
+    throw new YorkieError(
+      Code.ErrInvalidArgument,
+      "DedupCounter must contain Int"
+    );
+  }
   if (value.__yson_type === "Counter" && typeof value.__yson_data === "object") {
     const counterValue = postprocessValue(value.__yson_data);
     if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && (counterValue.type === "Int" || counterValue.type === "Long")) {
@@ -22085,6 +22778,7 @@ const YSON = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty
   isBinData,
   isCounter,
   isDate,
+  isDedupCounter,
   isInt,
   isLong,
   isObject,