@ray-js/lock-sdk 1.2.0-beta.8 → 1.2.0

package/lib/feature/storage/swr-cache.js

@@ -0,0 +1,54 @@
+import { getRuntimeByDevId } from "../../runtime/registry";
+import { sdkLog } from "../../utils/sdk-log";
+import { getStorageForRuntime, setStorageForRuntime } from "./index";
+const CACHE_KEY_PREFIX = "swr_";
+const buildKey = (key) => `${CACHE_KEY_PREFIX}${key}`;
+function readValidCache(rt, storageKey, version, maxAge) {
+    const envelope = getStorageForRuntime(rt, storageKey);
+    if (!envelope ||
+        typeof envelope !== "object" ||
+        envelope.v !== version ||
+        !("data" in envelope)) {
+        return { hit: false };
+    }
+    if (typeof maxAge === "number" && maxAge >= 0 && Date.now() - envelope.t > maxAge) {
+        return { hit: false };
+    }
+    return { hit: true, data: envelope.data };
+}
+export async function getWithLocalCache(rt, key, fetcher, options) {
+    if (!rt.config.localCache) {
+        return fetcher();
+    }
+    const version = options?.version ?? 1;
+    const storageKey = buildKey(key);
+    const devId = rt.devId;
+    const writeCache = (data) => {
+        if (getRuntimeByDevId(devId) !== rt) {
+            return;
+        }
+        const envelope = { v: version, t: Date.now(), data };
+        setStorageForRuntime(rt, storageKey, envelope);
+    };
+    const cached = readValidCache(rt, storageKey, version, options?.maxAge);
+    if (cached.hit) {
+        void (async () => {
+            try {
+                const fresh = await fetcher();
+                writeCache(fresh);
+                options?.applyToSession?.(rt, fresh);
+            }
+            catch (error) {
+                sdkLog("warn", "swrCache", "revalidateFailed", {
+                    devId,
+                    data: { key },
+                    error,
+                });
+            }
+        })();
+        return cached.data;
+    }
+    const fresh = await fetcher();
+    writeCache(fresh);
+    return fresh;
+}

package/lib/feature/unlock/method/add-flow.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { parallelOnlyForRuntime } from "../../utils";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import emitter from "../../../utils/event";
@@ -207,7 +207,7 @@ const handleAddReport = async (dps) => {
                         const res = await createUnlockMethod({
                             devId: cfg.devInfo.devId,
                             userId: addUnlockMethodData.userId,
-                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
                             unlockName: "",
                             unlockAttr: 0,
                         });

package/lib/feature/unlock/method/add-password.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { encrypt } from "../../../platform/device";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getUnlockMethodBase } from "./internal/base";
@@ -76,7 +76,7 @@ export async function addPasswordForRuntime(rt, params) {
         const result = await createUnlockMethod({
             devId: devId,
             userId: params.userId,
-            unlockId: `${dpId}-${res.unlockId}`,
+            unlockId: formatCloudUnlockId(dpId, res.unlockId),
             unlockName: params.name,
             unlockDetail: aesPwd,
             ...specialInfo,

package/lib/feature/user/sync-user.js

@@ -3,10 +3,12 @@ import { deleteUserForRuntime } from "./delete-user-dp";
 import { isUseNearChannelForRuntime } from "../misc/is-use-near-channel-for-runtime";
 import { publishDpsOnlyWithRuntime, } from "../dp/publish-dps";
 import dpCodes from "../../config/dp-code";
-import { isBlePureDeviceForRuntime } from "../misc/capability";
+import { hasCapabilityForRuntime, isBlePureDeviceForRuntime } from "../misc/capability";
 import { sdkLog } from "../../utils/sdk-log";
+import { ProductCommunicationType } from "../../constant";
 export async function syncDeleteUsersWithRuntime(runtime) {
-    if (runtime.config.devInfo.wifiEnableState !== 1) {
+    const hasWifi = hasCapabilityForRuntime(runtime, ProductCommunicationType.WIFI);
+    if (hasWifi && runtime.config.devInfo.wifiEnableState !== 1) {
         sdkLog("debug", "syncUser", "deleteUsersSkipped", {
             devId: runtime.devId,
             data: { reason: "wifiActive" },

package/lib/feature/utils/index.d.ts

@@ -1,5 +1,6 @@
 import type { UnlockMethodConfig } from "../../interface";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const unlockMethodDpCodes: string[];
 export declare const getUnlockMethodTypeByDpCodeForRuntime: (rt: LockDeviceRuntime, dpCode: string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByIdForRuntime: (rt: LockDeviceRuntime, id: number | string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByTypeForRuntime: (rt: LockDeviceRuntime, type: string) => UnlockMethodConfig;

package/lib/feature/utils/index.js

@@ -33,6 +33,7 @@ const unlockMethodConfigs = [
         id: 6,
     },
 ];
+export const unlockMethodDpCodes = unlockMethodConfigs.reduce((res, item) => res.concat(item.codes), []);
 const getUnlockMethodTypeForRuntime = (rt, cb) => {
     const result = unlockMethodConfigs.find(cb);
     if (result) {

package/lib/interface.d.ts

@@ -12,9 +12,12 @@ export interface LockSDKOption {
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
     preFetch?: boolean;
+    localCache?: boolean;
+    notSupportWake?: boolean;
     logLevel?: SDKLogLevel;
     logger?: SDKLogSink;
     logToConsole?: boolean;
+    kind?: "lock" | "fit" | "screen";
 }
 export interface ErrorData {
     errorCode: number;
@@ -180,6 +183,16 @@ export interface EffectiveConfig {
     effectiveTime?: number;
     expiredTime?: number;
 }
+export interface FitBleKeyItem {
+    id: string;
+    unlockBindingId: string;
+    name: string;
+    opModeSubType?: number;
+    effectiveConfig: EffectiveConfig;
+    sn?: number;
+    userName?: string;
+    devNameList?: string[];
+}
 export interface UnBindUnlockMethod {
     dpId: number;
     dpCode: string;
@@ -204,6 +217,8 @@ export interface DeviceStatus {
     };
     isWifiActive: boolean;
     isWifiMatter: boolean;
+    isActiveThread: boolean;
+    isShareThread: boolean;
 }
 export interface UnionUnlockInfo {
     userId: string;
@@ -254,6 +269,11 @@ export interface MediaInfo {
     fileUrl: string;
     mediaBucket: string;
     mediaKey: string;
+    width: number;
+    height: number;
+    angle: number;
+    position: number;
+    isVR: boolean;
 }
 export type LogType = "alarm_record" | "close_record" | "unlock_record" | "operation" | "local_operation";
 export type CloseValue = "UNDEFINED" | "VOICE_REMOTE" | "APP_REMOTE" | "AUTO" | "LOCAL_MANUAL" | "FITTINGS" | "APP" | "GEO_FENCE";
@@ -269,6 +289,8 @@ export interface LogData {
     dpCode: string;
     data: any;
     userName: string;
+    avatarUrl?: string;
+    relateDevName?: string;
     bindable: boolean;
     unlockName: string;
     mediaInfo?: MediaInfo[];
@@ -402,4 +424,11 @@ export interface AIReportPopup {
     reportId: string;
     yearMonth: number;
 }
+export interface CameraConfig {
+    isVR: boolean;
+    width: number;
+    height: number;
+    rotate: number;
+    location: number;
+}
 export {};

package/lib/platform/device.d.ts

@@ -52,7 +52,7 @@ export declare const getSystemInfoSync: () => {
     locationEnabled: boolean;
     wifiEnabled: boolean;
     theme?: ty.Themes;
-    deviceOrientation?: ty.Orientation;
+    deviceOrientation?: ty.PhoneOrientation;
     deviceLevel: string;
     isSupportPinShortcut?: boolean;
     deviceType?: string;
@@ -74,9 +74,10 @@ export declare const requestCloud: <T>(options: {
 export declare const getLaunchOptionsSync: () => {
     path: string;
     scene?: ty.MiniAppScene;
-    query: any;
+    query: Record<string, any>;
     referrerInfo: ty.ReferrerInfo;
     apiCategory?: string;
+    extraQuery?: Record<string, any>;
 };
 export declare function encrypt(deviceId: string, plaintext: string): Promise<string>;
 export declare function decrypt(deviceId: string, plaintext: string): Promise<string>;
@@ -219,7 +220,7 @@ export declare const onResetMemberName: (cb: HomeMemberListener) => void;
 export declare const offResetMemberName: (cb: HomeMemberListener) => void;
 export declare const onResetMemberRole: (cb: HomeMemberListener) => void;
 export declare const offResetMemberRole: (cb: HomeMemberListener) => void;
-export declare const getLogManager: () => ty.GetLogManagerTask;
+export declare const getLogManager: () => ty.LogManager;
 export declare const getAppUserInfo: () => Promise<{
     nickName: string;
     avatarUrl: string;

package/lib/platform/ipc.d.ts

@@ -10,5 +10,8 @@ declare const _default: {
     getCurrentSupportedTalkMode: (deviceId: string) => Promise<{
         talkbackMode: number;
     }>;
+    getTTTAbilityKeyList: (key: string) => Promise<{
+        abilityList: string[];
+    }>;
 };
 export default _default;

package/lib/platform/ipc.js

@@ -31,10 +31,23 @@ const getCurrentSupportedTalkMode = (deviceId) => {
     }
     return Promise.reject(new Error("not support"));
 };
+const getTTTAbilityKeyList = (key) => {
+    if (ty.ipc.getTTTAbilityKeyList) {
+        return new Promise((resolve, reject) => {
+            ty.ipc.getTTTAbilityKeyList({
+                key,
+                success: resolve,
+                fail: reject,
+            });
+        });
+    }
+    return Promise.resolve({ abilityList: [] });
+};
 export default {
     wakeUpDoorBell,
     isConnected,
     isConnecting,
     connect,
     getCurrentSupportedTalkMode,
+    getTTTAbilityKeyList,
 };

package/lib/platform/storage.d.ts

@@ -1,3 +1,3 @@
-export declare const setStorageSync: (key: string, data: unknown) => void;
+export declare const setStorageSync: (key: string, data: string) => void;
 export declare const getStorageSync: (key: string) => any;
 export declare const removeStorageSync: (key: string) => void;

package/lib/runtime/LockDeviceRuntime.js

@@ -14,6 +14,7 @@ export class LockDeviceRuntime {
             offlineDpCache: undefined,
             isActiveThreadCache: false,
             deviceAdvanceAbilityCache: undefined,
+            fitDeviceBvCache: undefined,
         };
         this.sync = {
             hasSyncedT0: false,
@@ -21,6 +22,8 @@ export class LockDeviceRuntime {
             unlockMethodAutoSyncEnabled: true,
             tempAutoSyncEnabled: true,
             tempPayloadSyncing: false,
+            fitSyncReportHandler: null,
+            fitBindingsSyncStarted: false,
         };
         this.infra = {
             eventsRegistered: false,

package/lib/runtime/lock-config.d.ts

@@ -1,5 +1,5 @@
 import { ProductCommunicationType, RemotePermissionType } from "../constant";
-import { CapabilityInfo, DeviceInfo, DeviceStatus, DpSchema } from "../interface";
+import { CameraConfig, CapabilityInfo, DeviceInfo, DeviceStatus, DpSchema } from "../interface";
 export type LockConfigState = {
     devInfo: DeviceInfo;
     dpSchema: Record<string, DpSchema>;
@@ -21,8 +21,12 @@ export type LockConfigState = {
     supportMultipleFace: boolean;
     supportOfflineDps: boolean;
     preFetch: boolean;
+    localCache: boolean;
     supportTalk: boolean;
     isTwoWayTalk: boolean;
+    cameraConfig: CameraConfig[];
+    notSupportWake: boolean;
+    isFitting: boolean;
 };
 export declare function createDefaultDeviceStatus(): DeviceStatus;
 export declare function createLockConfigState(): LockConfigState;

package/lib/runtime/lock-config.js

@@ -7,6 +7,8 @@ export function createDefaultDeviceStatus() {
         onlineTypes: [],
         isWifiActive: false,
         isWifiMatter: false,
+        isActiveThread: false,
+        isShareThread: false,
     };
 }
 export function createLockConfigState() {
@@ -31,7 +33,11 @@ export function createLockConfigState() {
         supportMultipleFace: false,
         supportOfflineDps: false,
         preFetch: false,
+        localCache: true,
         supportTalk: false,
         isTwoWayTalk: false,
+        cameraConfig: [],
+        notSupportWake: false,
+        isFitting: false
     };
 }

package/lib/runtime/runtime-state-types.d.ts

@@ -5,6 +5,7 @@ export interface LockRuntimeCacheFields {
     offlineDpCache: OfflineDps | undefined;
     isActiveThreadCache: boolean;
     deviceAdvanceAbilityCache: DeviceAdvancedAbility | undefined;
+    fitDeviceBvCache: Promise<number> | undefined;
 }
 export interface LockRuntimeSyncFlags {
     hasSyncedT0: boolean;
@@ -12,6 +13,11 @@ export interface LockRuntimeSyncFlags {
     unlockMethodAutoSyncEnabled: boolean;
     tempAutoSyncEnabled: boolean;
     tempPayloadSyncing: boolean;
+    fitSyncReportHandler: ((data: {
+        deviceId?: string;
+        data?: string;
+    }) => void) | null;
+    fitBindingsSyncStarted: boolean;
 }
 export interface LockRuntimeInfraFields {
     eventsRegistered: boolean;

package/lib/utils/constant.d.ts

@@ -12,3 +12,4 @@ export declare enum LoopTypes {
     WEEK = 2,
     MONTH = 3
 }
+export declare const cameraPositionMap: Record<number, number>;

package/lib/utils/constant.js

@@ -14,3 +14,9 @@ export var LoopTypes;
     LoopTypes[LoopTypes["WEEK"] = 2] = "WEEK";
     LoopTypes[LoopTypes["MONTH"] = 3] = "MONTH";
 })(LoopTypes || (LoopTypes = {}));
+export const cameraPositionMap = {
+    0: 4,
+    1: 3,
+    2: 5,
+    3: 6,
+};

package/lib/utils/index.d.ts

@@ -32,7 +32,7 @@ export declare const getSystemInfo: () => {
     locationEnabled: boolean;
     wifiEnabled: boolean;
     theme?: ty.Themes;
-    deviceOrientation?: ty.Orientation;
+    deviceOrientation?: ty.PhoneOrientation;
     deviceLevel: string;
     isSupportPinShortcut?: boolean;
     deviceType?: string;
@@ -121,6 +121,7 @@ export declare function getCapabilities(capability: number): ({
     readonly short: "thread";
 })[];
 export declare const formatWeek: (value: number[]) => number;
+export declare const formatCloudUnlockId: (dpId: number | string, sn: number) => string;
 export declare const parseWeek: (value: number) => Week;
 export declare const getPermanentSetting: () => {
     startTime: number;

package/lib/utils/index.js

@@ -56,6 +56,7 @@ export const formatWeek = (value) => {
     const temp = value.slice(0, 7);
     return parseInt(temp.reverse().join(""), 2);
 };
+export const formatCloudUnlockId = (dpId, sn) => `${dpId}-${sn.toString(16).padStart(2, "0")}`;
 export const parseWeek = (value) => {
     return Number(value)
         .toString(2)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.2.0-beta.8",
+  "version": "1.2.0",
   "files": [
     "lib",
     "LICENSE.md"
@@ -12,16 +12,6 @@
       "types": "./lib/index.d.ts",
       "import": "./lib/index.js",
       "default": "./lib/index.js"
-    },
-    "./fit": {
-      "types": "./lib/fit.d.ts",
-      "import": "./lib/fit.js",
-      "default": "./lib/fit.js"
-    },
-    "./screen": {
-      "types": "./lib/screen.d.ts",
-      "import": "./lib/screen.js",
-      "default": "./lib/screen.js"
     }
   },
   "scripts": {

package/lib/bootstrap/bootstrap-lock-instance.d.ts

@@ -1,7 +0,0 @@
-import type { LockSDKOption } from "../interface";
-import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-import { type LockSDKInstance } from "../entries/main/build-instance";
-export declare function bootstrapRegisteredLockInstance(options?: LockSDKOption): Promise<{
-    runtime: LockDeviceRuntime;
-    instance: LockSDKInstance;
-}>;

package/lib/bootstrap/bootstrap-lock-instance.js

@@ -1,16 +0,0 @@
-import { addEvents } from "../feature/state/platform-routing";
-import { initState } from "../feature/state/init-state";
-import { registerRuntime } from "../runtime/registry";
-import { buildLockSDKInstance, } from "../entries/main/build-instance";
-import * as MainDeviceExports from "../entries/main/exports";
-import { createBootstrappedRuntime } from "./bootstrap";
-export async function bootstrapRegisteredLockInstance(options) {
-    const runtime = await createBootstrappedRuntime(options);
-    registerRuntime(runtime);
-    addEvents(runtime);
-    await initState(runtime);
-    return {
-        runtime,
-        instance: buildLockSDKInstance(runtime, MainDeviceExports),
-    };
-}

package/lib/bootstrap/bootstrap.d.ts

@@ -1,4 +0,0 @@
-import type { LockSDKOption } from "../interface";
-import { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-export declare function applyLockOptionsToRuntime(runtime: LockDeviceRuntime, options?: LockSDKOption): Promise<void>;
-export declare function createBootstrappedRuntime(options?: LockSDKOption): Promise<LockDeviceRuntime>;

package/lib/bootstrap/bootstrap.js

@@ -1,53 +0,0 @@
-import dpCodes from "../config/dp-code";
-import { getCapabilities } from "../utils";
-import { getDeviceInfo, trackEvent } from "../platform/device";
-import { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-export async function applyLockOptionsToRuntime(runtime, options) {
-    const { config } = runtime;
-    let { devInfo, deviceId } = options || {};
-    if (!devInfo && !deviceId) {
-        throw new Error("deviceId is required in lock sdk");
-    }
-    if (deviceId && (!devInfo || devInfo.devId !== deviceId)) {
-        devInfo = await getDeviceInfo(deviceId);
-    }
-    let dpSchema = {};
-    const codesById = {};
-    const idsByCode = {};
-    if (devInfo.schema) {
-        dpSchema = devInfo.schema.reduce((acc, cur) => {
-            acc[cur.code] = cur;
-            codesById[cur.id] = cur.code;
-            idsByCode[cur.code] = cur.id;
-            return acc;
-        }, {});
-    }
-    else if (devInfo.dpSchema) {
-        dpSchema = devInfo.dpSchema;
-        Object.keys(dpSchema).forEach((key) => {
-            const item = dpSchema[key];
-            codesById[item.id] = item.code;
-            idsByCode[item.code] = item.id;
-        });
-    }
-    config.strictMode = options?.strictMode ?? true;
-    config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
-    config.passwordSupportZero = options?.passwordSupportZero ?? true;
-    config.supportMultipleFace = options?.supportMultipleFace ?? false;
-    config.supportOfflineDps = options?.supportOfflineDps ?? false;
-    config.devInfo = devInfo;
-    config.dpSchema = dpSchema;
-    config.codesById = codesById;
-    config.idsByCode = idsByCode;
-    config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
-    config.preFetch = options?.preFetch ?? false;
-    config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
-    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
-        pid: devInfo.productId,
-    });
-}
-export async function createBootstrappedRuntime(options) {
-    const runtime = new LockDeviceRuntime();
-    await applyLockOptionsToRuntime(runtime, options);
-    return runtime;
-}

package/lib/bootstrap/lock-instance-runtime-ref.d.ts

@@ -1,3 +0,0 @@
-import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-export declare function registerLockSDKInstanceRuntime(instance: object, runtime: LockDeviceRuntime): void;
-export declare function getRuntimeForLockSDKInstance(instance: object): LockDeviceRuntime | undefined;

package/lib/bootstrap/lock-instance-runtime-ref.js

@@ -1,7 +0,0 @@
-const runtimeByInstance = new WeakMap();
-export function registerLockSDKInstanceRuntime(instance, runtime) {
-    runtimeByInstance.set(instance, runtime);
-}
-export function getRuntimeForLockSDKInstance(instance) {
-    return runtimeByInstance.get(instance);
-}

package/lib/bootstrap/primary-instance.d.ts

@@ -1,6 +0,0 @@
-import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-import type { LockSDKInstance } from "../entries/main/build-instance";
-export declare function setPrimaryLockSDKInstance(instance: LockSDKInstance): void;
-export declare function getPrimaryLockSDKRuntime(): LockDeviceRuntime | null;
-export declare function clearPrimaryLockSDKInstance(): void;
-export declare function clearPrimaryLockSDKInstanceIfDevId(devId: string): void;

package/lib/bootstrap/primary-instance.js

@@ -1,24 +0,0 @@
-import { getRuntimeForLockSDKInstance } from "./lock-instance-runtime-ref";
-let primaryDevId = null;
-let primaryRuntime = null;
-export function setPrimaryLockSDKInstance(instance) {
-    const runtime = getRuntimeForLockSDKInstance(instance);
-    if (!runtime) {
-        throw new Error("setPrimaryLockSDKInstance: instance must be returned by createLockSDK or init");
-    }
-    primaryDevId = runtime.devId;
-    primaryRuntime = runtime;
-}
-export function getPrimaryLockSDKRuntime() {
-    return primaryRuntime;
-}
-export function clearPrimaryLockSDKInstance() {
-    primaryDevId = null;
-    primaryRuntime = null;
-}
-export function clearPrimaryLockSDKInstanceIfDevId(devId) {
-    if (primaryDevId === devId) {
-        primaryDevId = null;
-        primaryRuntime = null;
-    }
-}

package/lib/bootstrap/resolve-runtime-from-export-this.d.ts

@@ -1,5 +0,0 @@
-import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-export type LockSdkBoundExportThis = {
-    devId: string;
-};
-export declare function resolveRuntimeFromExportThis(thisArg: unknown): LockDeviceRuntime;

package/lib/bootstrap/resolve-runtime-from-export-this.js

@@ -1,29 +0,0 @@
-import { getRuntimeByDevId } from "../runtime/registry";
-import { getRuntimeForLockSDKInstance } from "./lock-instance-runtime-ref";
-import { resolveTopLevelTargetRuntime } from "./top-level-runtime";
-export function resolveRuntimeFromExportThis(thisArg) {
-    if (thisArg !== null &&
-        thisArg !== undefined &&
-        typeof thisArg === "object") {
-        const rtFromInstance = getRuntimeForLockSDKInstance(thisArg);
-        if (rtFromInstance) {
-            return rtFromInstance;
-        }
-    }
-    if (thisArg !== null &&
-        thisArg !== undefined &&
-        typeof thisArg === "object" &&
-        "devId" in thisArg &&
-        typeof thisArg.devId === "string") {
-        const devId = thisArg.devId;
-        if (devId.length === 0) {
-            throw new Error("Lock SDK: bound context devId must be non-empty");
-        }
-        const rt = getRuntimeByDevId(devId);
-        if (!rt) {
-            throw new Error(`Lock SDK: no registered runtime for devId "${devId}"; use createLockSDK or init first`);
-        }
-        return rt;
-    }
-    return resolveTopLevelTargetRuntime();
-}

package/lib/bootstrap/top-level-runtime.d.ts

@@ -1,2 +0,0 @@
-import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
-export declare function resolveTopLevelTargetRuntime(): LockDeviceRuntime;

package/lib/bootstrap/top-level-runtime.js

@@ -1,9 +0,0 @@
-import { getError } from "../utils/errors";
-import { getPrimaryLockSDKRuntime } from "./primary-instance";
-export function resolveTopLevelTargetRuntime() {
-    const primary = getPrimaryLockSDKRuntime();
-    if (!primary) {
-        throw getError(1071);
-    }
-    return primary;
-}

package/lib/entries/ble/bootstrap/bootstrap-lock-instance.d.ts

@@ -1,7 +0,0 @@
-import type { LockSDKOption } from "../../../interface";
-import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
-import { type LockSDKInstance } from "../build-instance";
-export declare function bootstrapRegisteredLockInstance(options?: LockSDKOption): Promise<{
-    runtime: LockDeviceRuntime;
-    instance: LockSDKInstance;
-}>;

package/lib/entries/ble/bootstrap/bootstrap-lock-instance.js

@@ -1,12 +0,0 @@
-import { addEvents } from "../../../feature/state/platform-routing";
-import { initState } from "../../../feature/state/init-state";
-import { registerRuntime } from "../../../runtime/registry";
-import { buildLockSDKInstance, } from "../build-instance";
-import { createBootstrappedRuntime } from "./bootstrap";
-export async function bootstrapRegisteredLockInstance(options) {
-    const runtime = await createBootstrappedRuntime(options);
-    registerRuntime(runtime);
-    addEvents(runtime);
-    await initState(runtime);
-    return { runtime, instance: buildLockSDKInstance(runtime) };
-}

package/lib/entries/ble/bootstrap/bootstrap.d.ts

@@ -1,4 +0,0 @@
-import type { LockSDKOption } from "../../../interface";
-import { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
-export declare function applyLockOptionsToRuntime(runtime: LockDeviceRuntime, options?: LockSDKOption): Promise<void>;
-export declare function createBootstrappedRuntime(options?: LockSDKOption): Promise<LockDeviceRuntime>;