@uzuhq/code-sdk 0.7.5 → 0.7.7

package/dist/json-patch.js

@@ -1,78 +0,0 @@
-function escapePointer(key) {
-    return key.replace(/~/g, '~0').replace(/\//g, '~1');
-}
-function unescapePointer(token) {
-    return token.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-export function compare(oldObj, newObj, basePath = '') {
-    if (oldObj === newObj)
-        return [];
-    // Handle nulls / primitives
-    if (oldObj === null ||
-        newObj === null ||
-        typeof oldObj !== 'object' ||
-        typeof newObj !== 'object') {
-        return [{ op: 'replace', path: basePath || '/', value: newObj }];
-    }
-    // Arrays: compare as whole (no element-level diff)
-    if (Array.isArray(oldObj) || Array.isArray(newObj)) {
-        if (JSON.stringify(oldObj) === JSON.stringify(newObj))
-            return [];
-        return [{ op: 'replace', path: basePath || '/', value: newObj }];
-    }
-    // Objects: recurse
-    const ops = [];
-    const oldKeys = Object.keys(oldObj);
-    const newKeys = Object.keys(newObj);
-    // Removed keys
-    for (const key of oldKeys) {
-        if (!(key in newObj)) {
-            ops.push({ op: 'remove', path: `${basePath}/${escapePointer(key)}` });
-        }
-    }
-    // Added or changed keys
-    for (const key of newKeys) {
-        const childPath = `${basePath}/${escapePointer(key)}`;
-        if (!(key in oldObj)) {
-            ops.push({ op: 'add', path: childPath, value: newObj[key] });
-        }
-        else {
-            const childOps = compare(oldObj[key], newObj[key], childPath);
-            ops.push(...childOps);
-        }
-    }
-    return ops;
-}
-export function applyPatch(doc, ops) {
-    for (const op of ops) {
-        const tokens = op.path.split('/').slice(1).map(unescapePointer);
-        if (tokens.length === 0)
-            return false;
-        if (op.op === 'replace' || op.op === 'add') {
-            let target = doc;
-            for (let i = 0; i < tokens.length - 1; i++) {
-                target = target?.[tokens[i]];
-                if (target === undefined || target === null)
-                    return false;
-            }
-            const lastKey = tokens[tokens.length - 1];
-            target[lastKey] = op.value;
-        }
-        else if (op.op === 'remove') {
-            let target = doc;
-            for (let i = 0; i < tokens.length - 1; i++) {
-                target = target?.[tokens[i]];
-                if (target === undefined || target === null)
-                    return false;
-            }
-            const lastKey = tokens[tokens.length - 1];
-            if (Array.isArray(target)) {
-                target.splice(Number(lastKey), 1);
-            }
-            else {
-                delete target[lastKey];
-            }
-        }
-    }
-    return true;
-}

package/dist/random.d.ts

@@ -1,11 +0,0 @@
-import type { SeededRandom } from './types.js';
-export declare class SeededRandomImpl implements SeededRandom {
-    private _state;
-    constructor(seed: number);
-    get state(): number;
-    static fromState(state: number): SeededRandomImpl;
-    float(): number;
-    int(max: number): number;
-    pick<T>(array: T[]): T;
-    shuffle<T>(array: T[]): T[];
-}

package/dist/random.js

@@ -1,34 +0,0 @@
-export class SeededRandomImpl {
-    constructor(seed) {
-        this._state = seed | 0;
-    }
-    get state() {
-        return this._state;
-    }
-    static fromState(state) {
-        const r = new SeededRandomImpl(0);
-        r._state = state;
-        return r;
-    }
-    float() {
-        this._state |= 0;
-        this._state = (this._state + 0x6d2b79f5) | 0;
-        let t = Math.imul(this._state ^ (this._state >>> 15), 1 | this._state);
-        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    }
-    int(max) {
-        return Math.floor(this.float() * max);
-    }
-    pick(array) {
-        return array[this.int(array.length)];
-    }
-    shuffle(array) {
-        const a = [...array];
-        for (let i = a.length - 1; i > 0; i--) {
-            const j = this.int(i + 1);
-            [a[i], a[j]] = [a[j], a[i]];
-        }
-        return a;
-    }
-}

package/dist/reconnectable-ws.d.ts

@@ -1,60 +0,0 @@
-/**
- * 自動再接続 WebSocket ラッパー
- *
- * - Exponential backoff + jitter 付き自動再接続
- * - Heartbeat (__ping / __pong) による接続生存確認
- * - 再接続中のメッセージバッファリング
- */
-export type ConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
-export interface ReconnectableWSOptions {
-    /** 最大再接続試行回数 (default: 15) */
-    maxReconnectAttempts?: number;
-    /** Backoff の基準遅延 ms (default: 1000) */
-    baseDelay?: number;
-    /** Backoff の最大遅延 ms (default: 30000) */
-    maxDelay?: number;
-    /** Jitter 係数 0〜1 (default: 0.5) */
-    jitterFactor?: number;
-    /** Heartbeat 送信間隔 ms (default: 25000) */
-    heartbeatInterval?: number;
-    /** Pong 待ちタイムアウト ms (default: 10000) */
-    heartbeatTimeout?: number;
-    /** 再接続中のバッファ上限 (default: 50) */
-    maxBufferSize?: number;
-    /** バッファ対象判定。false を返すとドロップ */
-    shouldBuffer?: (data: string) => boolean;
-    /** 接続状態変更コールバック */
-    onConnectionStateChange?: (state: ConnectionState) => void;
-}
-export declare class ReconnectableWebSocket {
-    private ws;
-    private readonly url;
-    private readonly opts;
-    private _state;
-    private reconnectAttempt;
-    private messageBuffer;
-    private messageHandlers;
-    private heartbeatTimer;
-    private heartbeatTimeoutTimer;
-    private reconnectTimer;
-    private disposed;
-    constructor(url: string, options?: ReconnectableWSOptions);
-    get connectionState(): ConnectionState;
-    /** WebSocket.readyState 互換 (既存コードとの互換用) */
-    get readyState(): number;
-    send(data: string): void;
-    addEventListener(type: 'message', handler: (ev: MessageEvent) => void): void;
-    removeEventListener(type: 'message', handler: (ev: MessageEvent) => void): void;
-    /** バッファをクリア（権威的 state 受信時に呼ぶ） */
-    clearBuffer(): void;
-    /** 全リソース解放 */
-    dispose(): void;
-    private connect;
-    private setState;
-    private scheduleReconnect;
-    private getReconnectDelay;
-    private flushBuffer;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private handlePong;
-}

package/dist/reconnectable-ws.js

@@ -1,229 +0,0 @@
-/**
- * 自動再接続 WebSocket ラッパー
- *
- * - Exponential backoff + jitter 付き自動再接続
- * - Heartbeat (__ping / __pong) による接続生存確認
- * - 再接続中のメッセージバッファリング
- */
-const DEFAULTS = {
-    maxReconnectAttempts: 15,
-    baseDelay: 1000,
-    maxDelay: 30000,
-    jitterFactor: 0.5,
-    heartbeatInterval: 25000,
-    heartbeatTimeout: 10000,
-    maxBufferSize: 50,
-};
-export class ReconnectableWebSocket {
-    constructor(url, options = {}) {
-        this.ws = null;
-        this._state = 'connecting';
-        this.reconnectAttempt = 0;
-        this.messageBuffer = [];
-        this.messageHandlers = [];
-        this.heartbeatTimer = null;
-        this.heartbeatTimeoutTimer = null;
-        this.reconnectTimer = null;
-        this.disposed = false;
-        this.url = url;
-        this.opts = {
-            maxReconnectAttempts: options.maxReconnectAttempts ?? DEFAULTS.maxReconnectAttempts,
-            baseDelay: options.baseDelay ?? DEFAULTS.baseDelay,
-            maxDelay: options.maxDelay ?? DEFAULTS.maxDelay,
-            jitterFactor: options.jitterFactor ?? DEFAULTS.jitterFactor,
-            heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-            heartbeatTimeout: options.heartbeatTimeout ?? DEFAULTS.heartbeatTimeout,
-            maxBufferSize: options.maxBufferSize ?? DEFAULTS.maxBufferSize,
-            shouldBuffer: options.shouldBuffer,
-            onConnectionStateChange: options.onConnectionStateChange,
-        };
-        this.connect();
-    }
-    // ─── Public API ──────────────────────────────────────────
-    get connectionState() {
-        return this._state;
-    }
-    /** WebSocket.readyState 互換 (既存コードとの互換用) */
-    get readyState() {
-        return this.ws?.readyState ?? WebSocket.CLOSED;
-    }
-    send(data) {
-        if (this._state === 'connected' && this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.send(data);
-        }
-        else if (this._state === 'reconnecting') {
-            if (this.opts.shouldBuffer && !this.opts.shouldBuffer(data))
-                return;
-            if (this.messageBuffer.length < this.opts.maxBufferSize) {
-                this.messageBuffer.push(data);
-            }
-        }
-        // disconnected / connecting: ドロップ
-    }
-    addEventListener(type, handler) {
-        if (type === 'message') {
-            this.messageHandlers.push(handler);
-        }
-    }
-    removeEventListener(type, handler) {
-        if (type === 'message') {
-            const index = this.messageHandlers.indexOf(handler);
-            if (index !== -1) {
-                this.messageHandlers.splice(index, 1);
-            }
-        }
-    }
-    /** バッファをクリア（権威的 state 受信時に呼ぶ） */
-    clearBuffer() {
-        this.messageBuffer = [];
-    }
-    /** 全リソース解放 */
-    dispose() {
-        this.disposed = true;
-        this.stopHeartbeat();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        if (this.ws) {
-            this.ws.onopen = null;
-            this.ws.onclose = null;
-            this.ws.onerror = null;
-            this.ws.onmessage = null;
-            try {
-                if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-                    this.ws.close();
-                }
-            }
-            catch (e) {
-                console.warn('[ReconnectableWS] Error closing WebSocket:', e);
-            }
-            this.ws = null;
-        }
-    }
-    // ─── Private ─────────────────────────────────────────────
-    connect() {
-        if (this.disposed)
-            return;
-        console.log(`[ReconnectableWS] 🔗 Connecting to ${this.url} (attempt=${this.reconnectAttempt})`);
-        const ws = new WebSocket(this.url);
-        ws.onopen = () => {
-            if (this.disposed)
-                return;
-            console.log(`[ReconnectableWS] ✅ Connected`);
-            this.reconnectAttempt = 0;
-            this.setState('connected');
-            this.startHeartbeat();
-            this.flushBuffer();
-        };
-        ws.onclose = (ev) => {
-            if (this.disposed)
-                return;
-            // 正常終了 (1000) の場合はリコネクトしない
-            if (ev.code === 1000) {
-                console.log(`[ReconnectableWS] 🔒 Closed cleanly (code=${ev.code})`);
-                return;
-            }
-            console.log(`[ReconnectableWS] ❌ Closed (code=${ev.code} reason=${ev.reason})`);
-            this.stopHeartbeat();
-            this.scheduleReconnect();
-        };
-        ws.onerror = () => {
-            if (this.disposed)
-                return;
-            console.log(`[ReconnectableWS] ⚠️ Error`);
-            // onclose が後続で発火するため、ここではリコネクトをトリガーしない
-        };
-        ws.onmessage = (ev) => {
-            if (this.disposed)
-                return;
-            const data = ev.data;
-            // Heartbeat pong のフィルタリング
-            if (data === '__pong') {
-                this.handlePong();
-                return;
-            }
-            // 通常メッセージをハンドラに配信
-            for (const handler of this.messageHandlers) {
-                handler(ev);
-            }
-        };
-        this.ws = ws;
-    }
-    setState(state) {
-        if (this._state === state)
-            return;
-        this._state = state;
-        console.log(`[ReconnectableWS] 📡 State: ${state}`);
-        this.opts.onConnectionStateChange?.(state);
-    }
-    scheduleReconnect() {
-        if (this.disposed)
-            return;
-        if (this.reconnectAttempt >= this.opts.maxReconnectAttempts) {
-            console.log(`[ReconnectableWS] 🚫 Max reconnect attempts reached (${this.opts.maxReconnectAttempts})`);
-            this.setState('disconnected');
-            return;
-        }
-        this.setState('reconnecting');
-        const delay = this.getReconnectDelay();
-        console.log(`[ReconnectableWS] ⏳ Reconnecting in ${Math.round(delay)}ms (attempt=${this.reconnectAttempt + 1})`);
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectAttempt++;
-            this.connect();
-        }, delay);
-    }
-    getReconnectDelay() {
-        const { baseDelay, maxDelay, jitterFactor } = this.opts;
-        const exponentialDelay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempt), maxDelay);
-        const jitter = exponentialDelay * jitterFactor * (Math.random() * 2 - 1);
-        return Math.max(0, exponentialDelay + jitter);
-    }
-    flushBuffer() {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
-            return;
-        const buffer = this.messageBuffer;
-        this.messageBuffer = [];
-        for (const data of buffer) {
-            try {
-                this.ws.send(data);
-            }
-            catch (e) {
-                console.warn(`[ReconnectableWS] ⚠️ Failed to flush buffered message:`, e);
-            }
-        }
-        if (buffer.length > 0) {
-            console.log(`[ReconnectableWS] 📤 Flushed ${buffer.length} buffered messages`);
-        }
-    }
-    // ─── Heartbeat ───────────────────────────────────────────
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send('__ping');
-                this.heartbeatTimeoutTimer = setTimeout(() => {
-                    console.log(`[ReconnectableWS] 💔 Heartbeat timeout`);
-                    // 強制切断 → onclose がリコネクトをトリガー
-                    this.ws?.close(4001, 'heartbeat_timeout');
-                }, this.opts.heartbeatTimeout);
-            }
-        }, this.opts.heartbeatInterval);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.heartbeatTimeoutTimer) {
-            clearTimeout(this.heartbeatTimeoutTimer);
-            this.heartbeatTimeoutTimer = null;
-        }
-    }
-    handlePong() {
-        if (this.heartbeatTimeoutTimer) {
-            clearTimeout(this.heartbeatTimeoutTimer);
-            this.heartbeatTimeoutTimer = null;
-        }
-    }
-}

package/dist/room.d.ts

@@ -1,23 +0,0 @@
-type RoomMessageHandler = (data: Record<string, unknown>) => void;
-/** WebSocket 互換の send/addEventListener インターフェース */
-interface WebSocketLike {
-    send(data: string): void;
-    addEventListener(type: 'message', handler: (ev: MessageEvent) => void): void;
-}
-/** Room の公開インターフェース。WebSocket / BroadcastChannel どちらでも実装可能。 */
-export interface RoomLike {
-    readonly myId: string;
-    broadcast(msg: Record<string, unknown>): void;
-    send(id: string, msg: Record<string, unknown>): void;
-    on(type: string, handler: RoomMessageHandler): void;
-}
-export declare class Room implements RoomLike {
-    readonly myId: string;
-    private ws;
-    private handlers;
-    constructor(ws: WebSocketLike, myId: string);
-    broadcast(msg: Record<string, unknown>): void;
-    send(id: string, msg: Record<string, unknown>): void;
-    on(type: string, handler: RoomMessageHandler): void;
-}
-export {};

package/dist/room.js

@@ -1,36 +0,0 @@
-export class Room {
-    constructor(ws, myId) {
-        this.handlers = new Map();
-        this.ws = ws;
-        this.myId = myId;
-        this.ws.addEventListener('message', (ev) => {
-            let parsed;
-            try {
-                parsed = JSON.parse(ev.data);
-            }
-            catch {
-                return;
-            }
-            const type = parsed.type;
-            if (!type)
-                return;
-            const from = parsed.__from;
-            console.log(`[SDK Room] ⬅ recv type=${type} from=${from}`, JSON.stringify(parsed));
-            const handlers = this.handlers.get(type) || [];
-            handlers.forEach((h) => h({ ...parsed, __from: from }));
-        });
-    }
-    broadcast(msg) {
-        console.log(`[SDK Room] ➡ broadcast type=${msg.type}`, JSON.stringify(msg));
-        this.ws.send(JSON.stringify(msg));
-    }
-    send(id, msg) {
-        console.log(`[SDK Room] ➡ send to=${id} type=${msg.type}`, JSON.stringify(msg));
-        this.ws.send(JSON.stringify({ ...msg, __to: id }));
-    }
-    on(type, handler) {
-        if (!this.handlers.has(type))
-            this.handlers.set(type, []);
-        this.handlers.get(type).push(handler);
-    }
-}

package/dist/run/local-server-action.d.ts

@@ -1,16 +0,0 @@
-/**
- * @docs
- * - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
- * - SDK仕様: docs/docs/uzu_code/play-screen-sdk.md
- *
- * ブラウザ内 LocalGameRoom — GameRoom DO の動作をサーバーレスで再現する。
- * server_url がない場合に vite dev だけで ServerAction シナリオをローカル実行する。
- *
- * online (`runOnlineServerAction`) と挙動を揃えるため、`logic.actions` は同期で実行し
- * `sendAction()` 直後に `onState()` を同期発火する (楽観的更新だけで完結する仕様)。
- * `logic.serverActions` は `Promise<void>` を返しうるので `await` で実行し、完了後に
- * `onState()` を呼ぶ。同名なら actions → serverActions の順で走る (サーバーと同じ)。
- */
-import type { GameConfig } from '../types.js';
-import type { RunHandle } from '../dev-hooks.js';
-export declare function runLocalServerAction<S>(config: GameConfig<S>): RunHandle<S>;