@ray-js/lock-sdk 1.2.0-beta.1 → 1.2.0-beta.3

package/lib/api/index.d.ts

@@ -1,4 +1,4 @@
-import { DpValue } from "../interface";
+import { AIReportPopup, DpValue } from "../interface";
 export declare const sendPhoneVerifyCode: (params: {
     account: string;
     devId: string;
@@ -35,4 +35,6 @@ export declare const getFileRemoteUrl: ({ biz, resources, }: {
 }) => Promise<{
     signedUrls: Record<string, string>;
 }>;
+export declare const fetchAIReportPopup: (devId: string) => Promise<AIReportPopup | null>;
+export declare const acknowledgeAIReport: (devId: string, reportId: string) => Promise<void>;
 export {};

package/lib/api/index.js

@@ -90,3 +90,19 @@ export const getFileRemoteUrl = ({ biz, resources, }) => {
         },
     });
 };
+export const fetchAIReportPopup = (devId) => {
+    return requestApi({
+        logName: "fetchAIReportPopup",
+        api: "m.lock.ai.report.popup",
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const acknowledgeAIReport = (devId, reportId) => {
+    return requestApi({
+        logName: "acknowledgeAIReport",
+        api: "m.lock.ai.report.acknowledge",
+        version: "1.0",
+        data: { devId, reportId },
+    });
+};

package/lib/api/screen.d.ts

@@ -35,6 +35,7 @@ export interface BindableLockItem extends ScreenLockDeviceInfo {
     name: string;
     iconUrl: string;
     bindStatus: ScreenBindableStatus;
+    sessionId?: string;
 }
 export interface BindableLockListResult {
     bindLimit: number;

package/lib/entries/main/exports/ai.d.ts

@@ -0,0 +1,4 @@
+import type { AIReportPopup } from "../../../interface";
+export declare function getAIReport(): Promise<AIReportPopup | null>;
+export declare function acknowledgeAIReport(reportId: string): Promise<void>;
+export declare function isAIReportEnabled(): Promise<boolean>;

package/lib/entries/main/exports/ai.js

@@ -0,0 +1,11 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getAIReportForRuntime, acknowledgeAIReportForRuntime, isAIReportEnabledForRuntime, } from "../../../feature/ai/report";
+export async function getAIReport() {
+    return getAIReportForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function acknowledgeAIReport(reportId) {
+    return acknowledgeAIReportForRuntime(resolveRuntimeFromExportThis(this), reportId);
+}
+export async function isAIReportEnabled() {
+    return isAIReportEnabledForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/index.d.ts

@@ -15,6 +15,7 @@ export * from "./media";
 export * from "./voice-file";
 export * from "./linkage";
 export * from "./capability";
+export * from "./ai";
 export * from "./accessory-binding";
 export * from "./screen/list";
 export * from "./screen/bind";

package/lib/entries/main/exports/index.js

@@ -15,6 +15,7 @@ export * from "./media";
 export * from "./voice-file";
 export * from "./linkage";
 export * from "./capability";
+export * from "./ai";
 export * from "./accessory-binding";
 export * from "./screen/list";
 export * from "./screen/bind";

package/lib/entries/main/exports/screen/bind.d.ts

@@ -1,4 +1,7 @@
-import type { BindingResult, UnbindingResult } from "../../../../api/screen";
-export type { BindingResult, UnbindingResult };
-export declare function bindLockToScreen(lockDevId: string): Promise<BindingResult>;
+import { type BindLockToScreenEvent, type BindLockToScreenListener } from "../../../../feature/screen/bind-watch";
+import type { AddBindingResult, BindingResult, UnbindingResult } from "../../../../api/screen";
+export type { AddBindingResult, BindingResult, UnbindingResult, BindLockToScreenEvent, BindLockToScreenListener, };
+export declare function bindLockToScreen(lockDevId: string): Promise<AddBindingResult>;
+export declare function onBindLockToScreen(listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreen(listener: BindLockToScreenListener): void;
 export declare function unbindLockFromScreen(relationId: string): Promise<UnbindingResult>;

package/lib/entries/main/exports/screen/bind.js

@@ -1,8 +1,15 @@
 import { bindLockForRuntime, unbindLockForRuntime, } from "../../../../feature/screen/bind";
+import { onBindLockToScreenForRuntime, offBindLockToScreenForRuntime, } from "../../../../feature/screen/bind-watch";
 import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
 export function bindLockToScreen(lockDevId) {
     return bindLockForRuntime(resolveRuntimeFromExportThis(this), lockDevId);
 }
+export function onBindLockToScreen(listener) {
+    onBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function offBindLockToScreen(listener) {
+    offBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
 export function unbindLockFromScreen(relationId) {
     return unbindLockForRuntime(resolveRuntimeFromExportThis(this), relationId);
 }

package/lib/entries/screen/exports/bind-events.d.ts

@@ -0,0 +1,4 @@
+import { type BindLockToScreenEvent, type BindLockToScreenListener } from "../../../feature/screen/bind-watch";
+export type { BindLockToScreenEvent, BindLockToScreenListener };
+export declare function onBindLockToScreen(listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreen(listener: BindLockToScreenListener): void;

package/lib/entries/screen/exports/bind-events.js

@@ -0,0 +1,8 @@
+import { onBindLockToScreenForRuntime, offBindLockToScreenForRuntime, } from "../../../feature/screen/bind-watch";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export function onBindLockToScreen(listener) {
+    onBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function offBindLockToScreen(listener) {
+    offBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}

package/lib/entries/screen/exports/index.d.ts

@@ -2,3 +2,4 @@ export * from "./binding";
 export * from "./event";
 export * from "./user";
 export * from "./device";
+export * from "./bind-events";

package/lib/entries/screen/exports/index.js

@@ -2,3 +2,4 @@ export * from "./binding";
 export * from "./event";
 export * from "./user";
 export * from "./device";
+export * from "./bind-events";

package/lib/feature/ai/report.d.ts

@@ -0,0 +1,5 @@
+import type { AIReportPopup } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const isAIReportEnabledForRuntime: (runtime: LockDeviceRuntime) => Promise<boolean>;
+export declare const getAIReportForRuntime: (runtime: LockDeviceRuntime) => Promise<AIReportPopup | null>;
+export declare const acknowledgeAIReportForRuntime: (runtime: LockDeviceRuntime, reportId: string) => Promise<void>;

package/lib/feature/ai/report.js

@@ -0,0 +1,37 @@
+import { fetchAIReportPopup, acknowledgeAIReport as acknowledgeAIReportApi, } from "../../api";
+import { getDeviceProperties } from "../../api/setting";
+import { getDeviceAdvancedAbilitiesForRuntime } from "../misc/capability";
+const LOCK_UNLOCK_REPORT = "LOCK_UNLOCK_REPORT";
+export const isAIReportEnabledForRuntime = async (runtime) => {
+    const ability = await getDeviceAdvancedAbilitiesForRuntime(runtime);
+    const dataReport = !!ability?.ai?.config?.["ai_data_report"];
+    if (!dataReport) {
+        return false;
+    }
+    try {
+        const props = await getDeviceProperties(runtime.devId, [LOCK_UNLOCK_REPORT]);
+        return props?.[LOCK_UNLOCK_REPORT] !== "false";
+    }
+    catch {
+        return false;
+    }
+};
+export const getAIReportForRuntime = async (runtime) => {
+    const enabled = await isAIReportEnabledForRuntime(runtime);
+    if (!enabled) {
+        return null;
+    }
+    try {
+        const res = await fetchAIReportPopup(runtime.devId);
+        return res?.reportId ? res : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const acknowledgeAIReportForRuntime = async (runtime, reportId) => {
+    if (!reportId) {
+        return;
+    }
+    await acknowledgeAIReportApi(runtime.devId, reportId);
+};

package/lib/feature/screen/bind-watch.d.ts

@@ -0,0 +1,18 @@
+import { type BindingResult } from "../../api/screen";
+import type { ErrorData } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface BindLockToScreenEvent {
+    lockDevId: string;
+    success: boolean;
+    data?: BindingResult;
+    error?: ErrorData;
+}
+export type BindLockToScreenListener = (event: BindLockToScreenEvent) => void;
+export declare function emitBindResult(runtime: LockDeviceRuntime, event: BindLockToScreenEvent): void;
+export declare function onBindLockToScreenForRuntime(runtime: LockDeviceRuntime, listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreenForRuntime(runtime: LockDeviceRuntime, listener: BindLockToScreenListener): void;
+export declare function watchBindResult(runtime: LockDeviceRuntime, params: {
+    lockDevId: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function isWatchingBind(runtime: LockDeviceRuntime, sessionId: string): boolean;

package/lib/feature/screen/bind-watch.js

@@ -0,0 +1,92 @@
+import { getBindingResultApi } from "../../api/screen";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { handleScreenCloudError } from "./error";
+const POLL_INTERVAL_MS = 2_000;
+const BIND_POLL_TIMEOUT_MS = 30_000;
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+function bindResultEventName(runtime) {
+    return `screen_bind_result_${runtime.devId}`;
+}
+export function emitBindResult(runtime, event) {
+    emitter.emit(bindResultEventName(runtime), event);
+}
+const watchKey = (runtime, sessionId) => `${runtime.devId}:${sessionId}`;
+const inflight = new Map();
+export function onBindLockToScreenForRuntime(runtime, listener) {
+    emitter.on(bindResultEventName(runtime), listener);
+}
+export function offBindLockToScreenForRuntime(runtime, listener) {
+    emitter.off(bindResultEventName(runtime), listener);
+}
+async function pollBindResult(runtime, lockDevId, sessionId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    const deadline = startedAt + BIND_POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await delay(POLL_INTERVAL_MS);
+        let result;
+        try {
+            result = await getBindingResultApi({ accessoryDevId, sessionId });
+        }
+        catch (e) {
+            const error = handleScreenCloudError(e);
+            sdkLog("error", "screen", "bindResultPollError", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId },
+                error: e,
+            });
+            emitBindResult(runtime, { lockDevId, success: false, error });
+            return;
+        }
+        if (result.status === "binding") {
+            continue;
+        }
+        if (result.status === "bound") {
+            sdkLog("info", "screen", "bindResultSettled", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId, status: result.status, lanStatus: result.lanStatus },
+            });
+            emitBindResult(runtime, { lockDevId, success: true, data: result });
+            return;
+        }
+        sdkLog("info", "screen", "bindResultSettled", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId, status: result.status, lanStatus: result.lanStatus },
+        });
+        emitBindResult(runtime, {
+            lockDevId,
+            success: false,
+            data: result,
+            error: getError(1103),
+        });
+        return;
+    }
+    sdkLog("warn", "screen", "bindResultTimeout", {
+        devId: accessoryDevId,
+        duration: Date.now() - startedAt,
+        data: { lockDevId },
+    });
+    emitBindResult(runtime, { lockDevId, success: false, error: getError(1002) });
+}
+export function watchBindResult(runtime, params) {
+    const key = watchKey(runtime, params.sessionId);
+    const existing = inflight.get(key);
+    if (existing) {
+        return existing;
+    }
+    const task = pollBindResult(runtime, params.lockDevId, params.sessionId).finally(() => {
+        inflight.delete(key);
+    });
+    inflight.set(key, task);
+    return task;
+}
+export function isWatchingBind(runtime, sessionId) {
+    return inflight.has(watchKey(runtime, sessionId));
+}

package/lib/feature/screen/bind.d.ts

@@ -1,4 +1,4 @@
-import { type BindingResult, type UnbindingResult } from "../../api/screen";
+import { type AddBindingResult, type UnbindingResult } from "../../api/screen";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-export declare function bindLockForRuntime(runtime: LockDeviceRuntime, lockDevId: string): Promise<BindingResult>;
+export declare function bindLockForRuntime(runtime: LockDeviceRuntime, lockDevId: string): Promise<AddBindingResult>;
 export declare function unbindLockForRuntime(runtime: LockDeviceRuntime, relationId: string): Promise<UnbindingResult>;

package/lib/feature/screen/bind.js

@@ -1,11 +1,11 @@
-import { addBindingApi, deleteBindingApi, getBindingResultApi, getUnbindingResultApi, } from "../../api/screen";
+import { addBindingApi, deleteBindingApi, getUnbindingResultApi, } from "../../api/screen";
 import { getDeviceInfo } from "../../platform/device";
 import { getError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
 import { getDeviceStatusForRuntime } from "../state/device-status";
 import { handleScreenCloudError } from "./error";
+import { watchBindResult } from "./bind-watch";
 const POLL_INTERVAL_MS = 2_000;
-const BIND_POLL_TIMEOUT_MS = 25_000;
 const UNBIND_POLL_TIMEOUT_MS = 20_000;
 const delay = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -42,48 +42,18 @@ export async function bindLockForRuntime(runtime, lockDevId) {
             });
             sdkLog("info", "screen", "bindAddSuccess", {
                 devId: accessoryDevId,
+                duration: Date.now() - startedAt,
                 data: { lockDevId, relationId: sessionData.relationId },
             });
         }
         catch (e) {
             throw handleScreenCloudError(e);
         }
-        const deadline = Date.now() + BIND_POLL_TIMEOUT_MS;
-        let last;
-        while (Date.now() < deadline) {
-            await delay(POLL_INTERVAL_MS);
-            try {
-                last = await getBindingResultApi({
-                    accessoryDevId,
-                    sessionId: sessionData.sessionId,
-                });
-            }
-            catch (e) {
-                throw handleScreenCloudError(e);
-            }
-            if (last.status !== "binding") {
-                sdkLog("info", "screen", "bindSettled", {
-                    devId: accessoryDevId,
-                    duration: Date.now() - startedAt,
-                    data: {
-                        lockDevId,
-                        relationId: sessionData.relationId,
-                        status: last.status,
-                        lanStatus: last.lanStatus,
-                    },
-                });
-                if (last.status === "failed") {
-                    throw getError(1103);
-                }
-                return last;
-            }
-        }
-        sdkLog("warn", "screen", "bindTimeout", {
-            devId: accessoryDevId,
-            duration: Date.now() - startedAt,
-            data: { lockDevId, relationId: sessionData.relationId },
-        });
-        throw getError(1002);
+        void watchBindResult(runtime, {
+            lockDevId,
+            sessionId: sessionData.sessionId,
+        }).catch(() => { });
+        return sessionData;
     }
     catch (error) {
         sdkLog("error", "screen", "bindFail", {

package/lib/feature/screen/list.js

@@ -1,6 +1,7 @@
 import { getBoundLockListApi, getBindableLockListApi, } from "../../api/screen";
 import { getDeviceInfo } from "../../platform/device";
 import { sdkLog } from "../../utils/sdk-log";
+import { isWatchingBind, watchBindResult } from "./bind-watch";
 async function resolveLockDeviceInfo(accessoryDevId, lockDevId) {
     try {
         const info = await getDeviceInfo(lockDevId);
@@ -52,5 +53,17 @@ export async function getBindableLockListForRuntime(runtime) {
         duration: Date.now() - startedAt,
         data: { count: items.length, canBindMore: result?.canBindMore },
     });
+    for (const item of items) {
+        if (item.bindStatus !== "binding" || !item.sessionId) {
+            continue;
+        }
+        if (isWatchingBind(runtime, item.sessionId)) {
+            continue;
+        }
+        void watchBindResult(runtime, {
+            lockDevId: item.lockDevId,
+            sessionId: item.sessionId,
+        }).catch(() => { });
+    }
     return { ...result, items };
 }

package/lib/feature/state/init-state.js

@@ -16,6 +16,7 @@ import { fetchDeviceProperties } from "./remote-permissions";
 import { ipc, yuChannelSyncSingleSync } from "../../platform";
 import { sdkLog } from "../../utils/sdk-log";
 import { RotateType } from "../../constant";
+import { isHarmony } from "../../utils";
 export const initState = async (runtime) => {
     const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
     const startedAt = Date.now();
@@ -76,24 +77,31 @@ export const initState = async (runtime) => {
             }
             if (ipcConfig.status === "fulfilled" &&
                 ipcConfig.value?.audioAttributes?.hardwareCapability?.includes(2)) {
-                try {
-                    const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
+                if (isHarmony()) {
                     runtime.config.supportTalk = true;
-                    runtime.config.isTwoWayTalk = modeRes.talkbackMode === 2;
-                    sdkLog("info", "initState", "supportTalk", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                        data: {
-                            mode: modeRes.talkbackMode,
-                        },
-                    });
+                    runtime.config.isTwoWayTalk =
+                        ipcConfig.value?.audioAttributes?.callMode?.includes(2);
                 }
-                catch (e) {
-                    sdkLog("error", "initState", "supportTalk", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                        data: {},
-                    });
+                else {
+                    try {
+                        const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
+                        runtime.config.supportTalk = true;
+                        runtime.config.isTwoWayTalk = modeRes.talkbackMode === 2;
+                        sdkLog("info", "initState", "supportTalk", {
+                            devId,
+                            duration: Date.now() - startedAt,
+                            data: {
+                                mode: modeRes.talkbackMode,
+                            },
+                        });
+                    }
+                    catch (e) {
+                        sdkLog("error", "initState", "supportTalk", {
+                            devId,
+                            duration: Date.now() - startedAt,
+                            data: {},
+                        });
+                    }
                 }
             }
             if (!isSEI &&

package/lib/interface.d.ts

@@ -386,4 +386,8 @@ export interface SharedUserInfo {
     lockUserId: number;
     userExist: boolean;
 }
+export interface AIReportPopup {
+    reportId: string;
+    yearMonth: number;
+}
 export {};

package/lib/platform/device.d.ts

@@ -23,7 +23,7 @@ export declare const onOnlineChange: (func: ParamType<typeof ty.device.onDeviceO
 export declare const offOnlineChange: (func: ParamType<typeof ty.device.offDeviceOnlineStatusUpdate>) => void;
 export declare const onBleChange: (func: ParamType<typeof ty.device.onBLEConnectStatusChange>) => void;
 export declare const offBleChange: (func: ParamType<typeof ty.device.offBLEConnectStatusChange>) => void;
-export declare const getSystemInfo: () => {
+export declare const getSystemInfoSync: () => {
     is24Hour: boolean;
     system: string;
     brand: string;

package/lib/platform/device.js

@@ -98,7 +98,7 @@ export const onBleChange = (func) => {
 export const offBleChange = (func) => {
     ty.device.offBLEConnectStatusChange(func);
 };
-export const getSystemInfo = () => ty.getSystemInfoSync();
+export const getSystemInfoSync = () => ty.getSystemInfoSync();
 export const showModal = (options) => {
     return ty.showModal(options);
 };

package/lib/platform/ipc.js

@@ -19,14 +19,17 @@ const connect = (deviceId) => {
     });
 };
 const getCurrentSupportedTalkMode = (deviceId) => {
-    return new Promise((resolve, reject) => {
-        ty.ipc.getCurrentSupportedTalkMode({
-            deviceId,
-            extendParam: {},
-            success: resolve,
-            fail: reject,
+    if (ty.ipc.getCurrentSupportedTalkMode) {
+        return new Promise((resolve, reject) => {
+            ty.ipc.getCurrentSupportedTalkMode({
+                deviceId,
+                extendParam: {},
+                success: resolve,
+                fail: reject,
+            });
         });
-    });
+    }
+    return Promise.reject(new Error("not support"));
 };
 export default {
     wakeUpDoorBell,

package/lib/utils/index.d.ts

@@ -3,6 +3,40 @@ import type { EffectiveConfig, Week } from "../interface";
 import { LoopTypes } from "./constant";
 export declare const get24Time: (time: number) => number[];
 export declare const getNowTime: () => number;
+export declare const getSystemInfo: () => {
+    is24Hour: boolean;
+    system: string;
+    brand: string;
+    model: string;
+    platform: string;
+    timezoneId: string;
+    pixelRatio: number;
+    screenWidth: number;
+    screenHeight: number;
+    windowWidth: number;
+    windowHeight: number;
+    useableWindowWidth: number;
+    useableWindowHeight: number;
+    statusBarHeight: number;
+    language: string;
+    safeArea: ty.SafeArea;
+    albumAuthorized: boolean;
+    cameraAuthorized: boolean;
+    locationAuthorized: boolean;
+    microphoneAuthorized: boolean;
+    notificationAuthorized: boolean;
+    notificationAlertAuthorized: boolean;
+    notificationBadgeAuthorized: boolean;
+    notificationSoundAuthorized: boolean;
+    bluetoothEnabled: boolean;
+    locationEnabled: boolean;
+    wifiEnabled: boolean;
+    theme?: ty.Themes;
+    deviceOrientation?: ty.Orientation;
+    deviceLevel: string;
+    isSupportPinShortcut?: boolean;
+    deviceType?: string;
+};
 export declare const isOnlineByType: (onlineType: number, type: number) => boolean;
 export declare function isCapability(capability: number, id: number): boolean;
 export declare function getCapabilities(capability: number): ({
@@ -134,3 +168,4 @@ export declare const getAppUser: () => {
     phoneCode: string;
     isTemporaryUser: boolean;
 } | null;
+export declare const isHarmony: () => boolean;

package/lib/utils/index.js

@@ -1,5 +1,5 @@
 import { LoopTypes } from "./constant";
-import { getAppUserInfo, getCurrentHomeInfo } from "../platform/device";
+import { getAppUserInfo, getCurrentHomeInfo, getSystemInfoSync, } from "../platform/device";
 import { getError } from "./errors";
 export const get24Time = (time) => {
     const hours = Math.floor(time / 60);
@@ -10,6 +10,13 @@ export const getNowTime = () => {
     const now = new Date();
     return now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds();
 };
+let system;
+export const getSystemInfo = () => {
+    if (!system) {
+        system = getSystemInfoSync();
+    }
+    return system;
+};
 export const isOnlineByType = (onlineType, type) => {
     const base = 2 ** type;
     return (onlineType & base) >> type === 1;
@@ -210,3 +217,6 @@ const getAppUserAsync = async () => {
 getAppUserAsync().catch(() => {
     getAppUserAsync().catch(() => undefined);
 });
+export const isHarmony = () => {
+    return getSystemInfo().platform === "harmony";
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.2.0-beta.1",
+  "version": "1.2.0-beta.3",
   "files": [
     "lib",
     "LICENSE.md"