@lemoncloud/chatic-sockets-lib 0.3.1 → 0.3.3

package/dist/client-socket-v2/gateways/join-gateway.d.ts

@@ -0,0 +1,15 @@
+import type { JoinGetInput, JoinUpdateInput } from '../../lib/join/types';
+import type { ClientSocketV2 } from '../types';
+/**
+ * join 도메인 게이트웨이.
+ * - 응답은 @lemoncloud/chatic-socials-api 소유(pass-through)이므로 제네릭 T로 호출부에서 주입한다.
+ * - 미주입 시 unknown. 각 메서드 주석의 $socials.<View> 가 실제 응답 타입.
+ * - 입력의 `id` 는 Join.id이며 클라이언트가 보관한 값을 그대로 전달한다.
+ */
+export interface JoinGateway {
+    /** $socials.JoinView */
+    get<T = unknown>(data: JoinGetInput): Promise<T>;
+    /** $socials.JoinView */
+    update<T = unknown>(data: JoinUpdateInput): Promise<T>;
+}
+export declare const createJoinGateway: (client: ClientSocketV2) => JoinGateway;

package/dist/client-socket-v2/gateways/join-gateway.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJoinGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createJoinGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('join', client);
+    return {
+        get: (data) => gateway.request('get', data),
+        update: (data) => gateway.request('update', data),
+    };
+};
+exports.createJoinGateway = createJoinGateway;

package/dist/client-socket-v2/index.d.ts

@@ -18,13 +18,17 @@ export * from './socket-runtime';
 export * from './create-device-runtime';
 export * from './plans/device-sync-plan';
 export * from './plans/channel-sync-plan';
+export * from './plans/chat-sync-plan';
+export type { ChatSyncType, ChatSyncData, ChatSyncMessage } from '../lib/chat/types';
 export * from './plans/place-sync-plan';
+export * from './plans/join-sync-plan';
 export * from './plans/profile-sync-plan';
 export * from './gateways/create-domain-gateway';
 export * from './gateways/device-gateway';
 export * from './gateways/channel-gateway';
 export * from './gateways/auth-gateway';
 export * from './gateways/chat-gateway';
+export * from './gateways/join-gateway';
 export * from './gateways/cloud-gateway';
 export * from './gateways/user-gateway';
 export * from './gateways/place-gateway';

package/dist/client-socket-v2/index.js

@@ -36,13 +36,16 @@ __exportStar(require("./socket-runtime"), exports);
 __exportStar(require("./create-device-runtime"), exports);
 __exportStar(require("./plans/device-sync-plan"), exports);
 __exportStar(require("./plans/channel-sync-plan"), exports);
+__exportStar(require("./plans/chat-sync-plan"), exports);
 __exportStar(require("./plans/place-sync-plan"), exports);
+__exportStar(require("./plans/join-sync-plan"), exports);
 __exportStar(require("./plans/profile-sync-plan"), exports);
 __exportStar(require("./gateways/create-domain-gateway"), exports);
 __exportStar(require("./gateways/device-gateway"), exports);
 __exportStar(require("./gateways/channel-gateway"), exports);
 __exportStar(require("./gateways/auth-gateway"), exports);
 __exportStar(require("./gateways/chat-gateway"), exports);
+__exportStar(require("./gateways/join-gateway"), exports);
 __exportStar(require("./gateways/cloud-gateway"), exports);
 __exportStar(require("./gateways/user-gateway"), exports);
 __exportStar(require("./gateways/place-gateway"), exports);

package/dist/client-socket-v2/plans/channel-sync-plan.d.ts

@@ -1,27 +1,31 @@
-import type { ChannelView } from '../../modules/chat/views';
 import type { SocketMessage } from '../../lib/types';
-import type { DomainSyncContext, DomainSyncPlan, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
+import type { DomainSyncContext, DomainSyncPlan } from '../types';
+import type { SyncableView, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
 export interface ChannelSyncTarget extends SyncTargetDescriptor {
     type: 'channel';
 }
-export interface ChannelSyncSnapshot {
+export interface ChannelSyncSnapshot<TView extends SyncableView = SyncableView> {
     id?: string;
     updatedAt?: number;
-    view?: ChannelView;
+    view?: TView;
 }
-export interface ChannelSyncPlanOptions {
+export interface ChannelSyncPlanOptions<TView extends SyncableView = SyncableView> {
     intervalMs?: number;
     idleBackoff?: SyncBackoffOptions;
     resetSnapshotOnConnected?: boolean;
-    onUpdate?: (target: ChannelSyncTarget, view: ChannelView, previous?: ChannelSyncSnapshot) => void;
-    onRemove?: (target: ChannelSyncTarget, previous?: ChannelSyncSnapshot) => void;
+    onUpdate?: (target: ChannelSyncTarget, view: TView, previous?: ChannelSyncSnapshot<TView>) => void;
+    onRemove?: (target: ChannelSyncTarget, previous?: ChannelSyncSnapshot<TView>) => void;
 }
-/** Single-channel sync: polls `channel.get`, applies on `updatedAt` change, re-pulls on a `channel.sync` nudge. */
-export declare class ChannelSyncPlan implements DomainSyncPlan<ChannelSyncTarget> {
+/**
+ * Single-channel sync: polls `channel.get`, applies on `updatedAt` change, re-pulls on a `channel.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new ChannelSyncPlan<$socials.ChannelView>({ onUpdate })`.
+ */
+export declare class ChannelSyncPlan<TView extends SyncableView = SyncableView> implements DomainSyncPlan<ChannelSyncTarget> {
     private readonly options;
     readonly domain = "channel";
     readonly idleBackoff: SyncBackoffOptions;
-    constructor(options?: ChannelSyncPlanOptions);
+    constructor(options?: ChannelSyncPlanOptions<TView>);
     supports: (target: SyncTargetDescriptor) => target is ChannelSyncTarget;
     getKey: (target: ChannelSyncTarget) => string;
     getIntervalMs: (target: ChannelSyncTarget) => number;

package/dist/client-socket-v2/plans/channel-sync-plan.js

@@ -10,7 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelSyncPlan = void 0;
-/** Single-channel sync: polls `channel.get`, applies on `updatedAt` change, re-pulls on a `channel.sync` nudge. */
+/**
+ * Single-channel sync: polls `channel.get`, applies on `updatedAt` change, re-pulls on a `channel.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new ChannelSyncPlan<$socials.ChannelView>({ onUpdate })`.
+ */
 class ChannelSyncPlan {
     constructor(options = {}) {
         var _a;
@@ -30,7 +34,7 @@ class ChannelSyncPlan {
                 return;
             const prev = ctx.readSnapshot(target);
             const input = { id: target.id };
-            const view = yield ctx.client.request('channel.get', input);
+            const view = (yield ctx.client.request('channel.get', input));
             const nextUpdatedAt = typeof (view === null || view === void 0 ? void 0 : view.updatedAt) === 'number' ? view.updatedAt : undefined;
             const prevUpdatedAt = typeof (prev === null || prev === void 0 ? void 0 : prev.updatedAt) === 'number' ? prev.updatedAt : undefined;
             if (prevUpdatedAt === nextUpdatedAt && (prev === null || prev === void 0 ? void 0 : prev.view))

package/dist/client-socket-v2/plans/chat-sync-plan.d.ts

@@ -0,0 +1,63 @@
+import type { SocketMessage } from '../../lib/types';
+import type { DomainSyncContext, DomainSyncPlan } from '../types';
+import type { SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
+/**
+ * Minimal message shape the chat window requires: ordering key (`chatNo`) + channel scope (`channelId`).
+ * - The plan is generic over the message type; inject the concrete view at the call site,
+ *   e.g. `new ChatSyncPlan<$socials.ChatView>({ onApply })`.
+ */
+export interface ChatMessageLike {
+    chatNo?: number;
+    channelId?: string;
+}
+/** Sync target for one channel's chat messages. */
+export interface ChatSyncTarget extends SyncTargetDescriptor {
+    type: 'chat';
+}
+/** Applied message window. `lastNo` is the top (next expected is `lastNo + 1`); messages older than `minNo` are left for the app to lazy-load. */
+export interface ChatSyncSnapshot<TMessage extends ChatMessageLike = ChatMessageLike> {
+    id: string;
+    lastNo: number;
+    minNo: number;
+    messages: TMessage[];
+}
+export interface ChatSyncPlanOptions<TMessage extends ChatMessageLike = ChatMessageLike> {
+    /** Max messages fetched in one catch-up; anything older is left for the app to lazy-load. Default 50. */
+    cap?: number;
+    /** Max messages kept in the snapshot window to bound memory; the app holds full history via `onApply`. Default 500. */
+    maxMessages?: number;
+    idleBackoff?: SyncBackoffOptions;
+    /** Called after messages are applied, with the applied delta (ascending) and the new snapshot. */
+    onApply?: (target: ChatSyncTarget, applied: TMessage[], snapshot: ChatSyncSnapshot<TMessage>) => void;
+    /** Called when the engine stops the target. */
+    onRemove?: (target: ChatSyncTarget, previous?: ChatSyncSnapshot<TMessage>) => void;
+}
+/**
+ * Per-channel chat message sync (append-only events).
+ * - `onTrigger` (chat.sync): applies the message payload directly, with no read round-trip on the normal path.
+ * - `onConnected`: catches up from `lastNo` to `channel.chatNo` (bounded by `cap`) after a reconnect.
+ * - `run`: no-op (event-driven, no polling).
+ */
+export declare class ChatSyncPlan<TMessage extends ChatMessageLike = ChatMessageLike> implements DomainSyncPlan<ChatSyncTarget> {
+    private readonly options;
+    readonly domain = "chat";
+    readonly idleBackoff: SyncBackoffOptions;
+    private readonly chains;
+    constructor(options?: ChatSyncPlanOptions<TMessage>);
+    supports: (target: SyncTargetDescriptor) => target is ChatSyncTarget;
+    getKey: (target: ChatSyncTarget) => string;
+    run: () => Promise<void>;
+    onConnected: (target: ChatSyncTarget, ctx: DomainSyncContext) => Promise<void>;
+    onTrigger: (target: ChatSyncTarget, message: SocketMessage<any>, ctx: DomainSyncContext) => Promise<void>;
+    onStopped: (target: ChatSyncTarget, _info: SyncFailureInfo, ctx: DomainSyncContext) => void;
+    updateLocalState: (target: ChatSyncTarget, snapshot: unknown, ctx: DomainSyncContext) => void;
+    /** Serialize read-modify-write per channel; the scheduler does not serialize onTrigger. */
+    private serialize;
+    private readSnap;
+    /** Append the contiguous `lastNo + 1 ..` run to the top of the window; gaps and duplicates are skipped. */
+    private appendContiguous;
+    /** Trim the window to `maxMessages`, dropping the oldest and advancing `minNo`. */
+    private clampWindow;
+    /** Reconnect/gap fill: collect newest-first, bound by `cap`, apply ascending, then set `lastNo` to `total`. */
+    private catchUp;
+}

package/dist/client-socket-v2/plans/chat-sync-plan.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSyncPlan = void 0;
+const num = (v, d = 0) => (typeof v === 'number' && Number.isFinite(v) ? v : d);
+/**
+ * Per-channel chat message sync (append-only events).
+ * - `onTrigger` (chat.sync): applies the message payload directly, with no read round-trip on the normal path.
+ * - `onConnected`: catches up from `lastNo` to `channel.chatNo` (bounded by `cap`) after a reconnect.
+ * - `run`: no-op (event-driven, no polling).
+ */
+class ChatSyncPlan {
+    constructor(options = {}) {
+        var _a;
+        this.options = options;
+        this.domain = 'chat';
+        this.chains = new Map();
+        this.supports = (target) => (target === null || target === void 0 ? void 0 : target.type) === 'chat';
+        this.getKey = (target) => { var _a; return `chat:${(_a = target === null || target === void 0 ? void 0 : target.id) !== null && _a !== void 0 ? _a : ''}`; };
+        this.run = () => __awaiter(this, void 0, void 0, function* () { return undefined; });
+        this.onConnected = (target, ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!target.id)
+                return;
+            // Swallow errors so one channel's catch-up failure cannot break the scheduler's reconnect loop; recovered on the next message or reconnect.
+            yield this.serialize(target.id, () => this.catchUp(target, ctx)).catch(() => undefined);
+        });
+        this.onTrigger = (target, message, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _b;
+            if (!target.id)
+                return;
+            const data = ((message === null || message === void 0 ? void 0 : message.data) || {});
+            const channelId = `${(_b = data === null || data === void 0 ? void 0 : data.channelId) !== null && _b !== void 0 ? _b : ''}`;
+            if (!channelId || channelId !== target.id)
+                return; // ignore other channels
+            const no = num(data === null || data === void 0 ? void 0 : data.chatNo, 0);
+            if (no <= 0)
+                return;
+            yield this.serialize(target.id, () => __awaiter(this, void 0, void 0, function* () {
+                const snap = this.readSnap(target, ctx);
+                if (no <= snap.lastNo)
+                    return; // duplicate or old
+                if (no === snap.lastNo + 1) {
+                    this.appendContiguous(target, ctx, snap, [data]); // apply payload directly, no feed
+                }
+                else {
+                    yield this.catchUp(target, ctx, snap); // gap: fill from the server
+                }
+            }));
+        });
+        this.onStopped = (target, _info, ctx) => {
+            var _a, _b;
+            const prev = ctx.readSnapshot(target);
+            if (target.id)
+                this.chains.delete(target.id);
+            (_b = (_a = this.options).onRemove) === null || _b === void 0 ? void 0 : _b.call(_a, target, prev);
+        };
+        this.updateLocalState = (target, snapshot, ctx) => {
+            const prev = this.readSnap(target, ctx);
+            const patch = (snapshot || {});
+            ctx.writeSnapshot(target, Object.assign(Object.assign({}, prev), patch));
+        };
+        /** Reconnect/gap fill: collect newest-first, bound by `cap`, apply ascending, then set `lastNo` to `total`. */
+        this.catchUp = (target, ctx, snapIn) => __awaiter(this, void 0, void 0, function* () {
+            var _c, _d, _e;
+            if (!target.id)
+                return;
+            const snap = snapIn !== null && snapIn !== void 0 ? snapIn : this.readSnap(target, ctx);
+            const input = { id: target.id };
+            const channel = (yield ctx.client.request('channel.get', input));
+            const total = num(channel === null || channel === void 0 ? void 0 : channel.chatNo, 0);
+            if (total <= snap.lastNo)
+                return; // already latest
+            const cap = num(this.options.cap, 50) || 50;
+            const floor = Math.max(snap.lastNo, total - cap); // below this is left for lazy-load
+            const acc = [];
+            let cursor;
+            for (let page = 0; page < 64; page += 1) {
+                const res = (yield ctx.client.request('chat.feed', Object.assign({ channelId: target.id }, (cursor ? { cursorNo: cursor } : {}))));
+                const list = ((_c = res === null || res === void 0 ? void 0 : res.list) !== null && _c !== void 0 ? _c : []);
+                let stop = false;
+                for (const m of list) {
+                    const mno = num(m.chatNo, 0);
+                    if (mno <= floor) {
+                        stop = true;
+                        break;
+                    }
+                    acc.push(m);
+                }
+                const cn = num(res === null || res === void 0 ? void 0 : res.cursorNo, 0);
+                if (stop || cn <= 0 || !list.length)
+                    break;
+                cursor = cn;
+            }
+            acc.sort((a, b) => num(a.chatNo, 0) - num(b.chatNo, 0));
+            if (floor === snap.lastNo) {
+                this.appendContiguous(target, ctx, snap, acc); // gap within cap: contiguous extend
+            }
+            else {
+                // Large gap: reset to the newest window and set lastNo to total, which avoids a re-fetch loop.
+                const win = this.clampWindow(acc, floor + 1);
+                const next = { id: snap.id, lastNo: total, minNo: win.minNo, messages: win.messages };
+                ctx.writeSnapshot(target, next);
+                (_e = (_d = this.options).onApply) === null || _e === void 0 ? void 0 : _e.call(_d, target, acc, next);
+            }
+        });
+        this.idleBackoff = (_a = options.idleBackoff) !== null && _a !== void 0 ? _a : { factor: 2, maxMs: 60000 };
+    }
+    // --- internals ---
+    /** Serialize read-modify-write per channel; the scheduler does not serialize onTrigger. */
+    serialize(key, task) {
+        var _a;
+        const prev = (_a = this.chains.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        const next = prev.then(task, task);
+        this.chains.set(key, next.then(() => undefined, () => undefined));
+        return next;
+    }
+    readSnap(target, ctx) {
+        var _a;
+        const prev = ctx.readSnapshot(target);
+        if (prev)
+            return prev;
+        return { id: `${(_a = target.id) !== null && _a !== void 0 ? _a : ''}`, lastNo: 0, minNo: 0, messages: [] };
+    }
+    /** Append the contiguous `lastNo + 1 ..` run to the top of the window; gaps and duplicates are skipped. */
+    appendContiguous(target, ctx, snap, ascending) {
+        var _a, _b;
+        const applied = [];
+        const messages = snap.messages.slice();
+        let lastNo = snap.lastNo;
+        let minNo = snap.minNo;
+        for (const m of ascending) {
+            const mno = num(m.chatNo, 0);
+            if (mno !== lastNo + 1)
+                continue;
+            messages.push(m);
+            lastNo = mno;
+            if (minNo === 0)
+                minNo = mno;
+            applied.push(m);
+        }
+        if (!applied.length)
+            return;
+        const win = this.clampWindow(messages, minNo);
+        const next = { id: snap.id, lastNo, minNo: win.minNo, messages: win.messages };
+        ctx.writeSnapshot(target, next);
+        (_b = (_a = this.options).onApply) === null || _b === void 0 ? void 0 : _b.call(_a, target, applied, next);
+    }
+    /** Trim the window to `maxMessages`, dropping the oldest and advancing `minNo`. */
+    clampWindow(messages, minNo) {
+        var _a;
+        const max = num(this.options.maxMessages, 500) || 500;
+        if (messages.length <= max)
+            return { messages, minNo };
+        const trimmed = messages.slice(messages.length - max);
+        return { messages: trimmed, minNo: num((_a = trimmed[0]) === null || _a === void 0 ? void 0 : _a.chatNo, minNo) };
+    }
+}
+exports.ChatSyncPlan = ChatSyncPlan;

package/dist/client-socket-v2/plans/join-sync-plan.d.ts

@@ -0,0 +1,37 @@
+import type { SocketMessage } from '../../lib/types';
+import type { DomainSyncContext, DomainSyncPlan } from '../types';
+import type { SyncableView, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
+export interface JoinSyncTarget extends SyncTargetDescriptor {
+    type: 'join';
+}
+export interface JoinSyncSnapshot<TView extends SyncableView = SyncableView> {
+    id?: string;
+    updatedAt?: number;
+    view?: TView;
+}
+export interface JoinSyncPlanOptions<TView extends SyncableView = SyncableView> {
+    intervalMs?: number;
+    idleBackoff?: SyncBackoffOptions;
+    resetSnapshotOnConnected?: boolean;
+    onUpdate?: (target: JoinSyncTarget, view: TView, previous?: JoinSyncSnapshot<TView>) => void;
+    onRemove?: (target: JoinSyncTarget, previous?: JoinSyncSnapshot<TView>) => void;
+}
+/**
+ * Single-join sync: polls `join.get`, applies on `updatedAt` change, re-pulls on a `join.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new JoinSyncPlan<$socials.JoinView>({ onUpdate })`.
+ */
+export declare class JoinSyncPlan<TView extends SyncableView = SyncableView> implements DomainSyncPlan<JoinSyncTarget> {
+    private readonly options;
+    readonly domain = "join";
+    readonly idleBackoff: SyncBackoffOptions;
+    constructor(options?: JoinSyncPlanOptions<TView>);
+    supports: (target: SyncTargetDescriptor) => target is JoinSyncTarget;
+    getKey: (target: JoinSyncTarget) => string;
+    getIntervalMs: (target: JoinSyncTarget) => number;
+    onConnected: (target: JoinSyncTarget, ctx: DomainSyncContext) => void;
+    run: (target: JoinSyncTarget, ctx: DomainSyncContext) => Promise<void>;
+    onTrigger: (target: JoinSyncTarget, message: SocketMessage<any>, ctx: DomainSyncContext) => Promise<void>;
+    onStopped: (target: JoinSyncTarget, _info: SyncFailureInfo, ctx: DomainSyncContext) => void;
+    updateLocalState: (target: JoinSyncTarget, snapshot: unknown, ctx: DomainSyncContext) => void;
+}

package/dist/client-socket-v2/plans/join-sync-plan.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinSyncPlan = void 0;
+/**
+ * Single-join sync: polls `join.get`, applies on `updatedAt` change, re-pulls on a `join.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new JoinSyncPlan<$socials.JoinView>({ onUpdate })`.
+ */
+class JoinSyncPlan {
+    constructor(options = {}) {
+        var _a;
+        this.options = options;
+        this.domain = 'join';
+        this.supports = (target) => (target === null || target === void 0 ? void 0 : target.type) === 'join';
+        this.getKey = (target) => { var _a; return `join:${(_a = target === null || target === void 0 ? void 0 : target.id) !== null && _a !== void 0 ? _a : ''}`; };
+        // Default poll interval (10s); the scheduler backs this off x2 up to 60s while idle.
+        this.getIntervalMs = (target) => { var _a, _b; return (_b = (_a = target.intervalMs) !== null && _a !== void 0 ? _a : this.options.intervalMs) !== null && _b !== void 0 ? _b : 10000; };
+        this.onConnected = (target, ctx) => {
+            if (this.options.resetSnapshotOnConnected === false)
+                return;
+            ctx.writeSnapshot(target, undefined);
+        };
+        this.run = (target, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _b, _c, _d, _e;
+            if (!target.id)
+                return;
+            const prev = ctx.readSnapshot(target);
+            const input = { id: target.id };
+            const view = (yield ctx.client.request('join.get', input));
+            const nextUpdatedAt = typeof (view === null || view === void 0 ? void 0 : view.updatedAt) === 'number' ? view.updatedAt : undefined;
+            const prevUpdatedAt = typeof (prev === null || prev === void 0 ? void 0 : prev.updatedAt) === 'number' ? prev.updatedAt : undefined;
+            if (prevUpdatedAt === nextUpdatedAt && (prev === null || prev === void 0 ? void 0 : prev.view))
+                return;
+            const next = {
+                id: `${(_c = (_b = view === null || view === void 0 ? void 0 : view.id) !== null && _b !== void 0 ? _b : target.id) !== null && _c !== void 0 ? _c : ''}` || undefined,
+                updatedAt: nextUpdatedAt,
+                view,
+            };
+            ctx.writeSnapshot(target, next);
+            (_e = (_d = this.options).onUpdate) === null || _e === void 0 ? void 0 : _e.call(_d, target, view, prev);
+        });
+        this.onTrigger = (target, message, ctx) => __awaiter(this, void 0, void 0, function* () {
+            const data = ((message === null || message === void 0 ? void 0 : message.data) || {});
+            if (target.id && (data === null || data === void 0 ? void 0 : data.id) && target.id !== data.id)
+                return;
+            yield this.run(target, ctx);
+        });
+        this.onStopped = (target, _info, ctx) => {
+            var _a, _b;
+            const prev = ctx.readSnapshot(target);
+            (_b = (_a = this.options).onRemove) === null || _b === void 0 ? void 0 : _b.call(_a, target, prev);
+        };
+        this.updateLocalState = (target, snapshot, ctx) => {
+            var _a, _b;
+            const prev = ctx.readSnapshot(target);
+            const patch = (snapshot || {});
+            ctx.writeSnapshot(target, Object.assign(Object.assign(Object.assign({}, prev), patch), { view: (_a = patch.view) !== null && _a !== void 0 ? _a : prev === null || prev === void 0 ? void 0 : prev.view, updatedAt: (_b = patch.updatedAt) !== null && _b !== void 0 ? _b : prev === null || prev === void 0 ? void 0 : prev.updatedAt }));
+        };
+        this.idleBackoff = (_a = options.idleBackoff) !== null && _a !== void 0 ? _a : { factor: 2, maxMs: 60000 };
+    }
+}
+exports.JoinSyncPlan = JoinSyncPlan;

package/dist/client-socket-v2/plans/place-sync-plan.d.ts

@@ -1,27 +1,31 @@
-import type * as $backend from '@lemoncloud/chatic-backend-api';
 import type { SocketMessage } from '../../lib/types';
-import type { DomainSyncContext, DomainSyncPlan, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
+import type { DomainSyncContext, DomainSyncPlan } from '../types';
+import type { SyncableView, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
 export interface PlaceSyncTarget extends SyncTargetDescriptor {
     type: 'place';
 }
-export interface PlaceSyncSnapshot {
+export interface PlaceSyncSnapshot<TView extends SyncableView = SyncableView> {
     id?: string;
     updatedAt?: number;
-    view?: $backend.MySiteView;
+    view?: TView;
 }
-export interface PlaceSyncPlanOptions {
+export interface PlaceSyncPlanOptions<TView extends SyncableView = SyncableView> {
     intervalMs?: number;
     idleBackoff?: SyncBackoffOptions;
     resetSnapshotOnConnected?: boolean;
-    onUpdate?: (target: PlaceSyncTarget, view: $backend.MySiteView, previous?: PlaceSyncSnapshot) => void;
-    onRemove?: (target: PlaceSyncTarget, previous?: PlaceSyncSnapshot) => void;
+    onUpdate?: (target: PlaceSyncTarget, view: TView, previous?: PlaceSyncSnapshot<TView>) => void;
+    onRemove?: (target: PlaceSyncTarget, previous?: PlaceSyncSnapshot<TView>) => void;
 }
-/** Single-place sync: polls `place.get`, applies on `updatedAt` change, re-pulls on a `place.sync` nudge. */
-export declare class PlaceSyncPlan implements DomainSyncPlan<PlaceSyncTarget> {
+/**
+ * Single-place sync: polls `place.get`, applies on `updatedAt` change, re-pulls on a `place.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new PlaceSyncPlan<$backend.MySiteView>({ onUpdate })`.
+ */
+export declare class PlaceSyncPlan<TView extends SyncableView = SyncableView> implements DomainSyncPlan<PlaceSyncTarget> {
     private readonly options;
     readonly domain = "place";
     readonly idleBackoff: SyncBackoffOptions;
-    constructor(options?: PlaceSyncPlanOptions);
+    constructor(options?: PlaceSyncPlanOptions<TView>);
     supports: (target: SyncTargetDescriptor) => target is PlaceSyncTarget;
     getKey: (target: PlaceSyncTarget) => string;
     getIntervalMs: (target: PlaceSyncTarget) => number;

package/dist/client-socket-v2/plans/place-sync-plan.js

@@ -10,7 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlaceSyncPlan = void 0;
-/** Single-place sync: polls `place.get`, applies on `updatedAt` change, re-pulls on a `place.sync` nudge. */
+/**
+ * Single-place sync: polls `place.get`, applies on `updatedAt` change, re-pulls on a `place.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new PlaceSyncPlan<$backend.MySiteView>({ onUpdate })`.
+ */
 class PlaceSyncPlan {
     constructor(options = {}) {
         var _a;
@@ -30,7 +34,6 @@ class PlaceSyncPlan {
                 return;
             const prev = ctx.readSnapshot(target);
             const input = { id: target.id };
-            // place.get 응답은 backend 소유(registry response=unknown) → MySiteView 로 단언
             const view = (yield ctx.client.request('place.get', input));
             const nextUpdatedAt = typeof (view === null || view === void 0 ? void 0 : view.updatedAt) === 'number' ? view.updatedAt : undefined;
             const prevUpdatedAt = typeof (prev === null || prev === void 0 ? void 0 : prev.updatedAt) === 'number' ? prev.updatedAt : undefined;

package/dist/client-socket-v2/plans/profile-sync-plan.d.ts

@@ -1,27 +1,31 @@
-import type { ProfileView } from '@lemoncloud/chatic-socials-api';
 import type { SocketMessage } from '../../lib/types';
-import type { DomainSyncContext, DomainSyncPlan, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
+import type { DomainSyncContext, DomainSyncPlan } from '../types';
+import type { SyncableView, SyncBackoffOptions, SyncFailureInfo, SyncTargetDescriptor } from '../types';
 export interface ProfileSyncTarget extends SyncTargetDescriptor {
     type: 'profile';
 }
-export interface ProfileSyncSnapshot {
+export interface ProfileSyncSnapshot<TView extends SyncableView = SyncableView> {
     id?: string;
     updatedAt?: number;
-    view?: ProfileView;
+    view?: TView;
 }
-export interface ProfileSyncPlanOptions {
+export interface ProfileSyncPlanOptions<TView extends SyncableView = SyncableView> {
     intervalMs?: number;
     idleBackoff?: SyncBackoffOptions;
     resetSnapshotOnConnected?: boolean;
-    onUpdate?: (target: ProfileSyncTarget, view: ProfileView, previous?: ProfileSyncSnapshot) => void;
-    onRemove?: (target: ProfileSyncTarget, previous?: ProfileSyncSnapshot) => void;
+    onUpdate?: (target: ProfileSyncTarget, view: TView, previous?: ProfileSyncSnapshot<TView>) => void;
+    onRemove?: (target: ProfileSyncTarget, previous?: ProfileSyncSnapshot<TView>) => void;
 }
-/** Single-profile sync: polls `profile.get`, applies on `updatedAt` change, re-pulls on a `profile.sync` nudge. */
-export declare class ProfileSyncPlan implements DomainSyncPlan<ProfileSyncTarget> {
+/**
+ * Single-profile sync: polls `profile.get`, applies on `updatedAt` change, re-pulls on a `profile.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new ProfileSyncPlan<$socials.ProfileView>({ onUpdate })`.
+ */
+export declare class ProfileSyncPlan<TView extends SyncableView = SyncableView> implements DomainSyncPlan<ProfileSyncTarget> {
     private readonly options;
     readonly domain = "profile";
     readonly idleBackoff: SyncBackoffOptions;
-    constructor(options?: ProfileSyncPlanOptions);
+    constructor(options?: ProfileSyncPlanOptions<TView>);
     supports: (target: SyncTargetDescriptor) => target is ProfileSyncTarget;
     getKey: (target: ProfileSyncTarget) => string;
     getIntervalMs: (target: ProfileSyncTarget) => number;

package/dist/client-socket-v2/plans/profile-sync-plan.js

@@ -10,7 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProfileSyncPlan = void 0;
-/** Single-profile sync: polls `profile.get`, applies on `updatedAt` change, re-pulls on a `profile.sync` nudge. */
+/**
+ * Single-profile sync: polls `profile.get`, applies on `updatedAt` change, re-pulls on a `profile.sync` nudge.
+ * - Generic over the view type: inject the concrete view at the call site,
+ *   e.g. `new ProfileSyncPlan<$socials.ProfileView>({ onUpdate })`.
+ */
 class ProfileSyncPlan {
     constructor(options = {}) {
         var _a;
@@ -30,7 +34,6 @@ class ProfileSyncPlan {
                 return;
             const prev = ctx.readSnapshot(target);
             const input = { id: target.id };
-            // profile.get 응답은 socials 소유(registry response=unknown) → ProfileView 로 단언
             const view = (yield ctx.client.request('profile.get', input));
             const nextUpdatedAt = typeof (view === null || view === void 0 ? void 0 : view.updatedAt) === 'number' ? view.updatedAt : undefined;
             const prevUpdatedAt = typeof (prev === null || prev === void 0 ? void 0 : prev.updatedAt) === 'number' ? prev.updatedAt : undefined;

package/dist/client-socket-v2/types.d.ts

@@ -117,6 +117,18 @@ export interface ClientSocketV2 {
     destroy(): void;
 }
 export declare type SyncTargetType = string;
+/**
+ * Minimal view shape a polling sync plan depends on — nothing else is read from the view.
+ * Concrete view types are owned by the external API, so plans stay generic over the view
+ * and the consumer injects the concrete type at the call site; this keeps the published
+ * `.d.ts` free of external-API dependencies.
+ */
+export interface SyncableView {
+    /** Stable identifier of the synced entity. */
+    id?: string;
+    /** Convergence axis — the plan re-applies the view only when this value changes. */
+    updatedAt?: number;
+}
 export interface SyncTargetDescriptor {
     type: SyncTargetType;
     id?: string;

package/dist/lib/channel/types.d.ts

@@ -1,6 +1,5 @@
 import type { InferSocketRequest, SocketRequestMessage } from '../types';
-import type { ChannelStereo } from '../../modules/chat/types';
-import type { ChannelView } from '../../modules/chat/views';
+import type { ChannelStereo, ChannelView } from '../chat/views';
 export interface ChannelCreateRequestData {
     stereo: ChannelStereo;
     name?: string;