com.kylin.di.messagepack 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to npmjs
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Publish package
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [1.0.0] - 2026-05-14
+
+### Added
+- SubscribableProperty<T> MessagePack formatter
+- SubscribableCollection<T> MessagePack formatter
+- SubscribableDictionary<TKey, TValue> MessagePack formatter
+- KDIMessagePackResolver with auto-registration via RuntimeInitializeOnLoadMethod
+- KDIMessagePackResolver.GetOptions() for manual configuration

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kylin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# KDI MessagePack Adapter
+
+KDI의 `SubscribableProperty`, `SubscribableCollection`, `SubscribableDictionary` 타입을 [MessagePack-CSharp](https://github.com/MessagePack-CSharp/MessagePack-CSharp)로 바이너리 직렬화할 수 있게 하는 어댑터 패키지.
+
+```
+com.kylin.di.messagepack v1.0.0 | Unity 6000.0+ | MIT License
+```
+
+---
+
+## 설치
+
+### 1. Scoped Registry 추가
+
+`Packages/manifest.json`에 다음을 추가:
+
+```json
+{
+  "scopedRegistries": [
+    {
+      "name": "Kylin",
+      "url": "https://www.npmjs.com/~kylin",
+      "scopes": ["com.kylin"]
+    }
+  ],
+  "dependencies": {
+    "com.kylin.di": "1.0.0",
+    "com.kylin.di.messagepack": "1.0.0"
+  }
+}
+```
+
+### 2. 전제 조건
+
+프로젝트에 MessagePack-CSharp가 설치되어 있어야 합니다. (NuGetForUnity 또는 직접 DLL 참조)
+
+---
+
+## 사용법
+
+### 자동 등록 (기본)
+
+**별도 설정이 필요 없습니다.** 패키지 설치만으로 `RuntimeInitializeOnLoadMethod`를 통해 자동으로 MessagePack 기본 옵션에 KDI 리졸버가 등록됩니다.
+
+```csharp
+// 그냥 평소처럼 직렬화하면 됩니다
+var health = new SubscribableProperty<int>(100);
+var bytes = MessagePackSerializer.Serialize(health);
+var restored = MessagePackSerializer.Deserialize<SubscribableProperty<int>>(bytes);
+// restored.Value == 100
+```
+
+### 데이터 클래스 예시
+
+```csharp
+[MessagePackObject]
+public class PlayerSaveData
+{
+    [Key(0)] public SubscribableProperty<int> Health { get; set; } = new(100);
+    [Key(1)] public SubscribableProperty<string> Name { get; set; } = new("Player");
+    [Key(2)] public SubscribableCollection<string> Inventory { get; set; } = new();
+    [Key(3)] public SubscribableDictionary<string, int> Stats { get; set; } = new();
+}
+
+// 직렬화
+var data = new PlayerSaveData();
+data.Health.Value = 80;
+data.Inventory.Add("Sword");
+data.Stats["ATK"] = 50;
+
+var bytes = MessagePackSerializer.Serialize(data);
+
+// 역직렬화 - 구독 가능한 프로퍼티로 복원됨
+var loaded = MessagePackSerializer.Deserialize<PlayerSaveData>(bytes);
+// loaded.Health.Value == 80
+// loaded.Inventory[0] == "Sword"
+// loaded.Stats["ATK"] == 50
+
+// 복원 후에도 구독이 정상 동작
+loaded.Health.Subscribe(hp => Debug.Log($"HP: {hp}"));
+loaded.Health.Value = 60; // "HP: 60" 출력
+```
+
+### 수동 옵션 구성 (선택)
+
+자동 등록 대신 수동으로 옵션을 구성하려면:
+
+```csharp
+var options = KDIMessagePackResolver.GetOptions();
+var bytes = MessagePackSerializer.Serialize(data, options);
+var loaded = MessagePackSerializer.Deserialize<PlayerSaveData>(bytes, options);
+```
+
+---
+
+## 동작 원리
+
+| KDI 타입 | 직렬화 형태 | 설명 |
+|----------|------------|------|
+| `SubscribableProperty<T>` | `T` 값 그대로 | 내부 `.Value`만 직렬화. 구독 상태는 직렬화하지 않음 |
+| `SubscribableCollection<T>` | MessagePack Array | 내부 아이템 리스트를 배열로 직렬화 |
+| `SubscribableDictionary<K,V>` | MessagePack Map | 내부 딕셔너리를 Map으로 직렬화 |
+
+역직렬화 시 새 인스턴스가 생성되며, 구독은 비어 있는 상태로 시작합니다. 이는 의도된 동작으로, 구독은 런타임에 코드로 설정하는 것이 올바른 패턴입니다.
+
+---
+
+## 의존성
+
+- `com.kylin.di` >= 1.0.0
+- MessagePack-CSharp >= 2.x

package/Runtime/KDIMessagePackResolver.cs

@@ -0,0 +1,107 @@
+using System;
+using Kylin.SubscribableProperty;
+using MessagePack;
+using MessagePack.Formatters;
+using MessagePack.Resolvers;
+using UnityEngine;
+
+namespace Kylin.Serialization.MessagePack
+{
+    /// <summary>
+    /// KDI SubscribableProperty 타입들을 MessagePack에서 직렬화할 수 있도록 하는 리졸버.
+    /// 런타임 초기화 시 자동으로 등록되므로 별도 설정이 필요 없다.
+    /// </summary>
+    public sealed class KDIMessagePackResolver : IFormatterResolver
+    {
+        public static readonly KDIMessagePackResolver Instance = new();
+
+        private KDIMessagePackResolver() { }
+
+        public IMessagePackFormatter<T> GetFormatter<T>()
+        {
+            return FormatterCache<T>.Formatter;
+        }
+
+        /// <summary>
+        /// 본 리졸버 + StandardResolver를 합성한 MessagePackSerializerOptions를 반환한다.
+        /// 수동으로 옵션을 구성할 때 사용한다.
+        /// </summary>
+        public static MessagePackSerializerOptions GetOptions()
+        {
+            var composite = CompositeResolver.Create(
+                Instance,
+                StandardResolver.Instance
+            );
+            return MessagePackSerializerOptions.Standard.WithResolver(composite);
+        }
+
+        /// <summary>
+        /// 제네릭 타입 캐시. 타입별로 한 번만 포맷터를 생성한다.
+        /// </summary>
+        private static class FormatterCache<T>
+        {
+            public static readonly IMessagePackFormatter<T> Formatter;
+
+            static FormatterCache()
+            {
+                Formatter = (IMessagePackFormatter<T>)ResolveFormatter(typeof(T));
+            }
+        }
+
+        private static object ResolveFormatter(Type type)
+        {
+            // SubscribableProperty<T>
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(SubscribableProperty<>))
+            {
+                var innerType = type.GetGenericArguments()[0];
+                var formatterType = typeof(SubscribablePropertyFormatter<>).MakeGenericType(innerType);
+                return Activator.CreateInstance(formatterType);
+            }
+
+            // SubscribableCollection<T>
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(SubscribableCollection<>))
+            {
+                var innerType = type.GetGenericArguments()[0];
+                var formatterType = typeof(SubscribableCollectionFormatter<>).MakeGenericType(innerType);
+                return Activator.CreateInstance(formatterType);
+            }
+
+            // SubscribableDictionary<TKey, TValue>
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(SubscribableDictionary<,>))
+            {
+                var genericArgs = type.GetGenericArguments();
+                var formatterType = typeof(SubscribableDictionaryFormatter<,>).MakeGenericType(genericArgs);
+                return Activator.CreateInstance(formatterType);
+            }
+
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// 런타임 초기화 시 KDI MessagePack 리졸버를 자동 등록한다.
+    /// 패키지 설치만으로 별도 코드 없이 즉시 사용 가능하다.
+    /// </summary>
+    public static class KDIMessagePackInitializer
+    {
+        private static bool _initialized;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void Initialize()
+        {
+            if (_initialized) return;
+            _initialized = true;
+
+            // KDI 리졸버를 기본 리졸버 앞에 합성하여 전역 기본 옵션으로 설정
+            var resolver = CompositeResolver.Create(
+                KDIMessagePackResolver.Instance,
+                StandardResolver.Instance
+            );
+
+            MessagePackSerializer.DefaultOptions =
+                MessagePackSerializerOptions.Standard.WithResolver(resolver);
+
+            Debug.Log("[KDI] MessagePack 어댑터가 자동 등록되었습니다.");
+        }
+    }
+}

package/Runtime/Kylin.DI.MessagePack.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Kylin.DI.MessagePack",
+    "rootNamespace": "Kylin.Serialization.MessagePack",
+    "references": [
+        "Kylin.DI"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/SubscribableCollectionFormatter.cs

@@ -0,0 +1,50 @@
+using Kylin.SubscribableProperty;
+using MessagePack;
+using MessagePack.Formatters;
+
+namespace Kylin.Serialization.MessagePack
+{
+    /// <summary>
+    /// SubscribableCollection{T}용 MessagePack 포맷터.
+    /// 내부 아이템 리스트를 배열로 직렬화/역직렬화한다.
+    /// </summary>
+    public sealed class SubscribableCollectionFormatter<T> : IMessagePackFormatter<SubscribableCollection<T>>
+    {
+        public void Serialize(ref MessagePackWriter writer, SubscribableCollection<T> value,
+            MessagePackSerializerOptions options)
+        {
+            if (value == null)
+            {
+                writer.WriteNil();
+                return;
+            }
+
+            var formatter = options.Resolver.GetFormatterWithVerify<T>();
+            var count = value.Count;
+            writer.WriteArrayHeader(count);
+
+            for (int i = 0; i < count; i++)
+            {
+                formatter.Serialize(ref writer, value[i], options);
+            }
+        }
+
+        public SubscribableCollection<T> Deserialize(ref MessagePackReader reader,
+            MessagePackSerializerOptions options)
+        {
+            if (reader.TryReadNil())
+                return null;
+
+            var formatter = options.Resolver.GetFormatterWithVerify<T>();
+            var count = reader.ReadArrayHeader();
+            var collection = new SubscribableCollection<T>(count);
+
+            for (int i = 0; i < count; i++)
+            {
+                collection.Add(formatter.Deserialize(ref reader, options));
+            }
+
+            return collection;
+        }
+    }
+}

package/Runtime/SubscribableDictionaryFormatter.cs

@@ -0,0 +1,57 @@
+using Kylin.SubscribableProperty;
+using MessagePack;
+using MessagePack.Formatters;
+
+namespace Kylin.Serialization.MessagePack
+{
+    /// <summary>
+    /// SubscribableDictionary{TKey, TValue}용 MessagePack 포맷터.
+    /// 내부 딕셔너리를 Map으로 직렬화/역직렬화한다.
+    /// </summary>
+    public sealed class SubscribableDictionaryFormatter<TKey, TValue>
+        : IMessagePackFormatter<SubscribableDictionary<TKey, TValue>>
+    {
+        public void Serialize(ref MessagePackWriter writer, SubscribableDictionary<TKey, TValue> value,
+            MessagePackSerializerOptions options)
+        {
+            if (value == null)
+            {
+                writer.WriteNil();
+                return;
+            }
+
+            var keyFormatter = options.Resolver.GetFormatterWithVerify<TKey>();
+            var valueFormatter = options.Resolver.GetFormatterWithVerify<TValue>();
+
+            writer.WriteMapHeader(value.Count);
+
+            foreach (var kvp in value)
+            {
+                keyFormatter.Serialize(ref writer, kvp.Key, options);
+                valueFormatter.Serialize(ref writer, kvp.Value, options);
+            }
+        }
+
+        public SubscribableDictionary<TKey, TValue> Deserialize(ref MessagePackReader reader,
+            MessagePackSerializerOptions options)
+        {
+            if (reader.TryReadNil())
+                return null;
+
+            var keyFormatter = options.Resolver.GetFormatterWithVerify<TKey>();
+            var valueFormatter = options.Resolver.GetFormatterWithVerify<TValue>();
+
+            var count = reader.ReadMapHeader();
+            var dict = new SubscribableDictionary<TKey, TValue>(count);
+
+            for (int i = 0; i < count; i++)
+            {
+                var key = keyFormatter.Deserialize(ref reader, options);
+                var val = valueFormatter.Deserialize(ref reader, options);
+                dict.Add(key, val);
+            }
+
+            return dict;
+        }
+    }
+}

package/Runtime/SubscribablePropertyFormatter.cs

@@ -0,0 +1,37 @@
+using Kylin.SubscribableProperty;
+using MessagePack;
+using MessagePack.Formatters;
+
+namespace Kylin.Serialization.MessagePack
+{
+    /// <summary>
+    /// SubscribableProperty{T}용 MessagePack 포맷터.
+    /// 내부 .Value (T) 만 직렬화/역직렬화한다.
+    /// </summary>
+    public sealed class SubscribablePropertyFormatter<T> : IMessagePackFormatter<SubscribableProperty<T>>
+    {
+        public void Serialize(ref MessagePackWriter writer, SubscribableProperty<T> value,
+            MessagePackSerializerOptions options)
+        {
+            if (value == null)
+            {
+                writer.WriteNil();
+                return;
+            }
+
+            var formatter = options.Resolver.GetFormatterWithVerify<T>();
+            formatter.Serialize(ref writer, value.Value, options);
+        }
+
+        public SubscribableProperty<T> Deserialize(ref MessagePackReader reader,
+            MessagePackSerializerOptions options)
+        {
+            if (reader.TryReadNil())
+                return null;
+
+            var formatter = options.Resolver.GetFormatterWithVerify<T>();
+            var innerValue = formatter.Deserialize(ref reader, options);
+            return new SubscribableProperty<T>(innerValue);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "com.kylin.di.messagepack",
+  "version": "1.0.0",
+  "displayName": "KDI MessagePack Adapter",
+  "description": "MessagePack-CSharp formatters for KDI SubscribableProperty types. Enables binary serialization of SubscribableProperty<T>, SubscribableCollection<T>, and SubscribableDictionary<TKey,TValue>.",
+  "unity": "6000.0",
+  "license": "MIT",
+  "keywords": [
+    "messagepack",
+    "serialization",
+    "kdi"
+  ],
+  "author": {
+    "name": "Kylin"
+  },
+  "dependencies": {
+    "com.kylin.di": "1.0.0"
+  }
+}