@lynx-js/react 0.105.1 → 0.105.2

package/runtime/src/internal.ts

@@ -5,12 +5,14 @@
 import { Suspense, createElement, lazy } from 'preact/compat';
 import type { FC } from 'react';
 
+import './lynx.js';
+
 import { factory as factory2 } from './compat/componentIs.js';
 import { useMemo } from './hooks/react.js';
 import { snapshotCreateList } from './list.js';
 import { loadLazyBundle } from './lynx/lazy-bundle.js';
 import { __root } from './root.js';
-import { DynamicPartType, SnapshotInstance, snapshotManager, __page, __pageId, createSnapshot } from './snapshot.js';
+import { DynamicPartType, SnapshotInstance, __page, __pageId, createSnapshot, snapshotManager } from './snapshot.js';
 
 export { __page, __pageId, __root };
 
@@ -47,7 +49,7 @@ export { wrapWithLynxComponent } from './compat/lynxComponent.js';
  * @internal a polyfill for <component is=? />
  */
 export const __ComponentIsPolyfill: FC<{ is: string }> = /* @__PURE__ */ factory2(
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
   { Suspense, lazy, createElement, useMemo } as any,
   loadLazyBundle,
 );

package/runtime/src/lifecycle/destroy.ts

@@ -4,7 +4,7 @@
 import { render } from 'preact';
 
 import { __root } from '../root.js';
-import { globalCommitTaskMap } from './patchUpdate.js';
+import { globalCommitTaskMap } from './patch/commit.js';
 
 function destroyBackground(): void {
   if (__PROFILE__) {

package/runtime/src/lifecycle/{patchUpdate.ts → patch/commit.ts}

@@ -1,31 +1,27 @@
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
-import { options } from 'preact';
 import type { VNode } from 'preact';
+import { options } from 'preact';
 import type { Component } from 'preact/compat';
 
-import { clearDelayedWorklets, updateWorkletRefInitValueChanges } from '@lynx-js/react/worklet-runtime/bindings';
-
-import { LifecycleConstant } from '../lifecycleConstant.js';
-import { __pendingListUpdates } from '../list.js';
-import { runDelayedUnmounts, takeDelayedUnmounts } from './delayUnmount.js';
-import { getReloadVersion } from './pass.js';
+import type { SnapshotPatch } from './snapshotPatch.js';
+import { takeGlobalSnapshotPatch } from './snapshotPatch.js';
+import { LifecycleConstant } from '../../lifecycleConstant.js';
 import {
   PerformanceTimingKeys,
   globalPipelineOptions,
   markTiming,
   markTimingLegacy,
   setPipeline,
-} from '../lynx/performance.js';
-import { CATCH_ERROR, COMMIT, RENDER_CALLBACKS, VNODE } from '../renderToOpcodes/constants.js';
-import { takeGlobalRefPatchMap, updateBackgroundRefs } from '../snapshot/ref.js';
-import { __page, backgroundSnapshotInstanceManager } from '../snapshot.js';
-import { takeGlobalSnapshotPatch } from '../snapshotPatch.js';
-import type { SnapshotPatch } from '../snapshotPatch.js';
-import { snapshotPatchApply } from '../snapshotPatchApply.js';
-import { isEmptyObject } from '../utils.js';
-import { takeWorkletRefInitValuePatch } from '../worklet/workletRefPool.js';
+} from '../../lynx/performance.js';
+import { CATCH_ERROR, COMMIT, RENDER_CALLBACKS, VNODE } from '../../renderToOpcodes/constants.js';
+import { updateBackgroundRefs } from '../../snapshot/ref.js';
+import { backgroundSnapshotInstanceManager } from '../../snapshot.js';
+import { isEmptyObject } from '../../utils.js';
+import { takeWorkletRefInitValuePatch } from '../../worklet/workletRefPool.js';
+import { runDelayedUnmounts, takeDelayedUnmounts } from '../delayUnmount.js';
+import { getReloadVersion } from '../pass.js';
 
 let globalFlushOptions: FlushOptions = {};
 
@@ -47,48 +43,6 @@ interface PatchOptions {
   isHydration?: boolean;
 }
 
-function injectUpdatePatch(): void {
-  function updatePatch(
-    { data, patchOptions }: {
-      data: string;
-      patchOptions: PatchOptions;
-    },
-  ): void {
-    if ((patchOptions.reloadVersion ?? 0) < getReloadVersion()) {
-      return;
-    }
-
-    setPipeline(patchOptions.pipelineOptions);
-    markTiming(PerformanceTimingKeys.parse_changes_start);
-    let { snapshotPatch, workletRefInitValuePatch, flushOptions } = JSON.parse(data) as Patch;
-    markTiming(PerformanceTimingKeys.parse_changes_end);
-
-    markTiming(PerformanceTimingKeys.patch_changes_start);
-    updateWorkletRefInitValueChanges(workletRefInitValuePatch);
-    __pendingListUpdates.clear();
-    if (snapshotPatch) {
-      snapshotPatchApply(snapshotPatch);
-    }
-    __pendingListUpdates.flush();
-    // console.debug('********** Lepus updatePatch:');
-    // printSnapshotInstance(snapshotInstanceManager.values.get(-1)!);
-
-    commitMainThreadPatchUpdate(patchOptions.commitTaskId);
-    if (patchOptions.isHydration) {
-      clearDelayedWorklets();
-    }
-    markTiming(PerformanceTimingKeys.patch_changes_end);
-    flushOptions ||= {};
-    if (patchOptions.pipelineOptions) {
-      flushOptions.pipelineOptions = patchOptions.pipelineOptions;
-    }
-    // TODO: triggerDataUpdated?
-    __FlushElementTree(__page, flushOptions);
-  }
-
-  Object.assign(globalThis, { [LifecycleConstant.patchUpdate]: updatePatch });
-}
-
 function replaceCommitHook(): void {
   const oldCommit = options[COMMIT];
   options[COMMIT] = async (vnode: VNode, commitQueue: any[]) => {
@@ -204,13 +158,6 @@ function commitPatchUpdate(data: Patch, patchOptions: PatchOptions): Promise<voi
   });
 }
 
-function commitMainThreadPatchUpdate(commitTaskId?: number): void {
-  const refPatch = takeGlobalRefPatchMap();
-  if (!isEmptyObject(refPatch)) {
-    __OnLifecycleEvent([LifecycleConstant.ref, { commitTaskId, refPatch: JSON.stringify(refPatch) }]);
-  }
-}
-
 function genCommitTaskId(): number {
   return nextCommitTaskId++;
 }
@@ -227,14 +174,14 @@ function replaceRequestAnimationFrame(): void {
  * @internal
  */
 export {
-  injectUpdatePatch,
   commitPatchUpdate,
-  replaceCommitHook,
   genCommitTaskId,
-  commitMainThreadPatchUpdate,
-  replaceRequestAnimationFrame,
-  globalFlushOptions,
-  globalCommitTaskMap,
   globalBackgroundSnapshotInstancesToRemove,
+  globalCommitTaskMap,
+  globalFlushOptions,
   nextCommitTaskId,
+  replaceCommitHook,
+  replaceRequestAnimationFrame,
+  type PatchOptions,
+  type Patch,
 };

package/runtime/src/{snapshotPatchApply.ts → lifecycle/patch/snapshotPatchApply.ts}

@@ -1,9 +1,9 @@
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
-import { createSnapshot, SnapshotInstance, snapshotInstanceManager, snapshotManager } from './snapshot.js';
 import type { SnapshotPatch } from './snapshotPatch.js';
 import { SnapshotOperation } from './snapshotPatch.js';
+import { SnapshotInstance, createSnapshot, snapshotInstanceManager, snapshotManager } from '../../snapshot.js';
 
 function reportCtxNotFound(): void {
   lynx.reportError(new Error(`snapshotPatchApply failed: ctx not found`));
@@ -25,7 +25,7 @@ export function snapshotPatchApply(snapshotPatch: SnapshotPatch): void {
         const beforeId = snapshotPatch[++i];
         const parent = snapshotInstanceManager.values.get(parentId);
         const child = snapshotInstanceManager.values.get(childId);
-        const existingNode = snapshotInstanceManager.values.get(beforeId!);
+        const existingNode = snapshotInstanceManager.values.get(beforeId);
         if (!parent || !child) {
           reportCtxNotFound();
         } else {

package/runtime/src/lifecycle/patch/updateMainThread.ts

@@ -0,0 +1,69 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+import { clearDelayedWorklets, updateWorkletRefInitValueChanges } from '@lynx-js/react/worklet-runtime/bindings';
+
+import { snapshotPatchApply } from './snapshotPatchApply.js';
+import { LifecycleConstant } from '../../lifecycleConstant.js';
+import { __pendingListUpdates } from '../../list.js';
+import { PerformanceTimingKeys, markTiming, setPipeline } from '../../lynx/performance.js';
+import { takeGlobalRefPatchMap } from '../../snapshot/ref.js';
+import { __page } from '../../snapshot.js';
+import { isEmptyObject } from '../../utils.js';
+import { getReloadVersion } from '../pass.js';
+import type { Patch, PatchOptions } from './commit.js';
+
+function updateMainThread(
+  { data, patchOptions }: {
+    data: string;
+    patchOptions: PatchOptions;
+  },
+): void {
+  if ((patchOptions.reloadVersion ?? 0) < getReloadVersion()) {
+    return;
+  }
+
+  setPipeline(patchOptions.pipelineOptions);
+  markTiming(PerformanceTimingKeys.parse_changes_start);
+  let { snapshotPatch, workletRefInitValuePatch, flushOptions } = JSON.parse(data) as Patch;
+  markTiming(PerformanceTimingKeys.parse_changes_end);
+
+  markTiming(PerformanceTimingKeys.patch_changes_start);
+  updateWorkletRefInitValueChanges(workletRefInitValuePatch);
+  __pendingListUpdates.clear();
+  if (snapshotPatch) {
+    snapshotPatchApply(snapshotPatch);
+  }
+  __pendingListUpdates.flush();
+  // console.debug('********** Lepus updatePatch:');
+  // printSnapshotInstance(snapshotInstanceManager.values.get(-1)!);
+
+  commitMainThreadPatchUpdate(patchOptions.commitTaskId);
+  if (patchOptions.isHydration) {
+    clearDelayedWorklets();
+  }
+  markTiming(PerformanceTimingKeys.patch_changes_end);
+  flushOptions ||= {};
+  if (patchOptions.pipelineOptions) {
+    flushOptions.pipelineOptions = patchOptions.pipelineOptions;
+  }
+  // TODO: triggerDataUpdated?
+  __FlushElementTree(__page, flushOptions);
+}
+
+function injectUpdateMainThread(): void {
+  Object.assign(globalThis, { [LifecycleConstant.patchUpdate]: updateMainThread });
+}
+
+function commitMainThreadPatchUpdate(commitTaskId?: number): void {
+  const refPatch = takeGlobalRefPatchMap();
+  if (!isEmptyObject(refPatch)) {
+    __OnLifecycleEvent([LifecycleConstant.ref, { commitTaskId, refPatch: JSON.stringify(refPatch) }]);
+  }
+}
+
+/**
+ * @internal
+ */
+export { injectUpdateMainThread, commitMainThreadPatchUpdate };

package/runtime/src/lifecycle/reload.ts

@@ -13,7 +13,7 @@ import { hydrate } from '../hydrate.js';
 import { LifecycleConstant } from '../lifecycleConstant.js';
 import { __pendingListUpdates } from '../list.js';
 import { takeGlobalRefPatchMap } from '../snapshot/ref.js';
-import { deinitGlobalSnapshotPatch } from '../snapshotPatch.js';
+import { deinitGlobalSnapshotPatch } from './patch/snapshotPatch.js';
 import { destroyWorklet } from '../worklet/destroy.js';
 
 function reloadMainThread(data: any, options: UpdatePageOption): void {

package/runtime/src/lifecycle/render.ts

@@ -24,7 +24,7 @@ function renderMainThread(): void {
       // @ts-ignore
       opcodes = renderToString(__root.__jsx);
     } catch (e) {
-      lynx.reportError(e);
+      lynx.reportError(e as Error);
       opcodes = [];
     } finally {
       if (__PROFILE__) {

package/runtime/src/list.ts

@@ -2,7 +2,7 @@
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
 import { hydrate } from './hydrate.js';
-import { commitMainThreadPatchUpdate } from './lifecycle/patchUpdate.js';
+import { commitMainThreadPatchUpdate } from './lifecycle/patch/updateMainThread.js';
 import type { SnapshotInstance } from './snapshot.js';
 
 export interface ListUpdateInfo {

package/runtime/src/lynx/component.ts

@@ -4,7 +4,7 @@
 import { Component } from 'preact';
 
 import { PerfSpecificKey, PerformanceTimingKeys, markTimingLegacy } from './performance.js';
-import { globalFlushOptions } from '../lifecycle/patchUpdate.js';
+import { globalFlushOptions } from '../lifecycle/patch/commit.js';
 import { NEXT_STATE } from '../renderToOpcodes/constants.js';
 
 if (__JS__) {
@@ -91,7 +91,7 @@ if (__JS__) {
 
   __Component.prototype.GlobalEventEmitter = lynxCoreInject.tt.GlobalEventEmitter;
 
-  __Component.prototype.createSelectorQuery = function(...args: any[]) {
+  __Component.prototype.createSelectorQuery = function() {
     if (!__DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__) {
       lynx.reportError(
         new Error(
@@ -99,7 +99,7 @@ if (__JS__) {
         ),
       );
     }
-    return lynx.createSelectorQuery(...args);
+    return lynx.createSelectorQuery();
   };
 
   const oldSetState = __Component.prototype.setState;

package/runtime/src/lynx/dynamic-js.ts

@@ -12,12 +12,11 @@ export function loadDynamicJS<T>(url: string): Promise<T> {
     return Promise.reject();
   }
   return new Promise((resolve, reject) => {
-    // @ts-ignore
-    lynx.requireModuleAsync(url, (err, data) => {
+    lynx.requireModuleAsync<T>(url, (err, data) => {
       if (err) {
         reject(err);
       } else {
-        resolve(data);
+        resolve(data as T);
       }
     });
   });

package/runtime/src/lynx/env.ts

@@ -94,8 +94,8 @@ export function setupLynxEnv(): void {
           }
         }
 
-        if (processorName) {
-        } else {
+        if (processorName) {}
+        else {
           hasDefaultDataProcessorExecuted = true;
         }
 

package/runtime/src/lynx/lazy-bundle.ts

@@ -96,7 +96,7 @@ export function loadLazyBundle<
       if (typeof lynx.QueryComponent === 'function') {
         lynx.QueryComponent(source, callback);
       } else {
-        lynx.getNativeLynx().QueryComponent(source, callback);
+        lynx.getNativeLynx().QueryComponent!(source, callback);
       }
     });
   }

package/runtime/src/lynx/performance.ts

@@ -3,8 +3,9 @@
 // LICENSE file in the root directory of this source tree.
 import { options } from 'preact';
 import type { VNode } from 'preact';
+
 import { DIFF } from '../renderToOpcodes/constants.js';
-import { __globalSnapshotPatch } from '../snapshotPatch.js';
+import { __globalSnapshotPatch } from '../lifecycle/patch/snapshotPatch.js';
 
 enum PerformanceTimingKeys {
   update_set_state_trigger,
@@ -61,7 +62,7 @@ function markTimingLegacy(key: PerformanceTimingKeys, timingFlag_?: string): voi
       break;
     }
   }
-  lynx.getNativeApp().markTiming?.(timingFlag, PerformanceTimingKeys[key]);
+  lynx.getNativeApp().markTiming?.(timingFlag!, PerformanceTimingKeys[key]);
 }
 
 function beginPipeline(needTimestamps: boolean, timingFlag?: string): void {

package/runtime/src/lynx/tt.ts

@@ -1,21 +1,70 @@
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
-import { render } from 'preact';
+import { options, render } from 'preact';
+import type { VNode } from 'preact';
 
 import { LifecycleConstant, NativeUpdateDataType } from '../lifecycleConstant.js';
 import { PerformanceTimingKeys, beginPipeline, markTiming } from './performance.js';
 import { BackgroundSnapshotInstance, hydrate } from '../backgroundSnapshot.js';
 import { destroyBackground } from '../lifecycle/destroy.js';
-import { commitPatchUpdate, genCommitTaskId, globalCommitTaskMap } from '../lifecycle/patchUpdate.js';
+import { commitPatchUpdate, genCommitTaskId, globalCommitTaskMap } from '../lifecycle/patch/commit.js';
 import { reloadBackground } from '../lifecycle/reload.js';
-import { runWithForce } from '../lynx.js';
-import { CHILDREN } from '../renderToOpcodes/constants.js';
+import { CHILDREN, COMPONENT, DIFF, DIFFED, FORCE } from '../renderToOpcodes/constants.js';
 import { __root } from '../root.js';
 import { globalRefsToSet, updateBackgroundRefs } from '../snapshot/ref.js';
 import { backgroundSnapshotInstanceManager } from '../snapshot.js';
 import { destroyWorklet } from '../worklet/destroy.js';
 
+export function runWithForce(cb: () => void): void {
+  // save vnode and its `_component` in WeakMap
+  const m = new WeakMap<VNode, any>();
+
+  const oldDiff = options[DIFF];
+
+  options[DIFF] = (vnode: VNode) => {
+    if (oldDiff) {
+      oldDiff(vnode);
+    }
+
+    // when `options[DIFF]` is called, a newVnode is passed in
+    // so its `vnode[COMPONENT]` should be null,
+    // but it will be set later
+    Object.defineProperty(vnode, COMPONENT, {
+      configurable: true,
+      set(c) {
+        m.set(vnode, c);
+        if (c) {
+          c[FORCE] = true;
+        }
+      },
+      get() {
+        return m.get(vnode);
+      },
+    });
+  };
+
+  const oldDiffed = options[DIFFED];
+
+  options[DIFFED] = (vnode: VNode) => {
+    if (oldDiffed) {
+      oldDiffed(vnode);
+    }
+
+    // delete is a reverse operation of previous `Object.defineProperty`
+    delete vnode[COMPONENT];
+    // restore
+    vnode[COMPONENT] = m.get(vnode);
+  };
+
+  try {
+    cb();
+  } finally {
+    options[DIFF] = oldDiff as (vnode: VNode) => void;
+    options[DIFFED] = oldDiffed as (vnode: VNode) => void;
+  }
+}
+
 function injectTt(): void {
   // @ts-ignore
   const tt = lynxCoreInject.tt;
@@ -76,7 +125,7 @@ async function OnLifecycleEvent([type, data]: [string, any]) {
           try {
             publishEvent([idStr, ...rest].join(':'), data);
           } catch (e) {
-            lynx.reportError(e);
+            lynx.reportError(e as Error);
           }
         });
         delayedEvents.length = 0;
@@ -139,7 +188,7 @@ function flushDelayedLifecycleEvents(): void {
       try {
         OnLifecycleEvent(e);
       } catch (e) {
-        lynx.reportError(e);
+        lynx.reportError(e as Error);
       }
     });
     delayedLifecycleEvents.length = 0;

package/runtime/src/lynx-api.ts

@@ -366,7 +366,7 @@ export interface Lynx {
    * ```
    * @public
    */
-  registerDataProcessors: (dataProcessorDefinition: DataProcessorDefinition) => void;
+  registerDataProcessors: (dataProcessorDefinition?: DataProcessorDefinition) => void;
 }
 
 export { runOnMainThread } from './worklet/runOnMainThread.js';

package/runtime/src/lynx.ts

@@ -2,81 +2,31 @@
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
 import { options } from 'preact';
-import type { VNode } from 'preact';
 // to make sure preact's hooks to register earlier than ours
 import './hooks/react.js';
 
 import { initProfileHook } from './debug/profile.js';
 import { document, setupBackgroundDocument } from './document.js';
 import { initDelayUnmount } from './lifecycle/delayUnmount.js';
-import { injectUpdatePatch, replaceCommitHook, replaceRequestAnimationFrame } from './lifecycle/patchUpdate.js';
+import { replaceCommitHook, replaceRequestAnimationFrame } from './lifecycle/patch/commit.js';
+import { injectUpdateMainThread } from './lifecycle/patch/updateMainThread.js';
 import { injectCalledByNative } from './lynx/calledByNative.js';
 import { setupLynxEnv } from './lynx/env.js';
 import { injectLepusMethods } from './lynx/injectLepusMethods.js';
 import { initTimingAPI } from './lynx/performance.js';
 import { injectTt } from './lynx/tt.js';
-import { COMPONENT, DIFF, DIFFED, FORCE } from './renderToOpcodes/constants.js';
 
 // @ts-expect-error Element implicitly has an 'any' type because type 'typeof globalThis' has no index signature
 if (__LEPUS__ && typeof globalThis.processEvalResult === 'undefined') {
   // @ts-expect-error Element implicitly has an 'any' type because type 'typeof globalThis' has no index signature
-  globalThis.processEvalResult = <T>(result: (schema: string) => T, schema: string) => {
-    return result(schema);
+  globalThis.processEvalResult = <T>(result: ((schema: string) => T) | undefined, schema: string) => {
+    return result?.(schema);
   };
 }
 
-export function runWithForce(cb: () => void): void {
-  // save vnode and its `_component` in WeakMap
-  const m = new WeakMap<VNode, any>();
-
-  const oldDiff = options[DIFF];
-
-  options[DIFF] = (vnode: VNode) => {
-    if (oldDiff) {
-      oldDiff(vnode);
-    }
-
-    // when `options[DIFF]` is called, a newVnode is passed in
-    // so its `vnode[COMPONENT]` should be null,
-    // but it will be set later
-    Object.defineProperty(vnode, COMPONENT, {
-      configurable: true,
-      set(c) {
-        m.set(vnode, c);
-        if (c) {
-          c[FORCE] = true;
-        }
-      },
-      get() {
-        return m.get(vnode);
-      },
-    });
-  };
-
-  const oldDiffed = options[DIFFED];
-
-  options[DIFFED] = (vnode: VNode) => {
-    if (oldDiffed) {
-      oldDiffed(vnode);
-    }
-
-    // delete is a reverse operation of previous `Object.defineProperty`
-    delete vnode[COMPONENT];
-    // restore
-    vnode[COMPONENT] = m.get(vnode);
-  };
-
-  try {
-    cb();
-  } finally {
-    options[DIFF] = oldDiff as (vnode: VNode) => void;
-    options[DIFFED] = oldDiffed as (vnode: VNode) => void;
-  }
-}
-
 if (__LEPUS__) {
   injectCalledByNative();
-  injectUpdatePatch();
+  injectUpdateMainThread();
   if (__DEV__) {
     injectLepusMethods();
   }

package/runtime/src/snapshot/ref.ts

@@ -3,13 +3,13 @@
 // LICENSE file in the root directory of this source tree.
 import type { Worklet, WorkletRef } from '@lynx-js/react/worklet-runtime/bindings';
 
-import { nextCommitTaskId } from '../lifecycle/patchUpdate.js';
+import { nextCommitTaskId } from '../lifecycle/patch/commit.js';
 import { SnapshotInstance, backgroundSnapshotInstanceManager } from '../snapshot.js';
 import { workletUnRef } from './workletRef.js';
 
 let globalRefPatch: Record<string, number | null> = {};
-let globalRefsToRemove: Map</* commitId */ number, Map</* sign */ string, /* ref */ any>> = /* @__PURE__ */ new Map();
-let globalRefsToSet: Map</* commitId */ number, Record<string, number>> = /* @__PURE__ */ new Map();
+const globalRefsToRemove: Map</* commitId */ number, Map</* sign */ string, /* ref */ any>> = /* @__PURE__ */ new Map();
+const globalRefsToSet: Map</* commitId */ number, Record<string, number>> = /* @__PURE__ */ new Map();
 let nextRefId = 1;
 
 function unref(snapshot: SnapshotInstance, recursive: boolean): void {
@@ -35,7 +35,7 @@ function unref(snapshot: SnapshotInstance, recursive: boolean): void {
 function applyRef(ref: any, value: any) {
   // TODO: ref: exceptions thrown in user functions should be able to be caught by an Error Boundary
   if (typeof ref == 'function') {
-    let hasRefUnmount = typeof ref._unmount == 'function';
+    const hasRefUnmount = typeof ref._unmount == 'function';
     if (hasRefUnmount) {
       // @ts-ignore TS doesn't like moving narrowing checks into variables
       ref._unmount();
@@ -54,7 +54,7 @@ function updateBackgroundRefs(commitId: number): void {
   const oldRefMap = globalRefsToRemove.get(commitId);
   if (oldRefMap) {
     globalRefsToRemove.delete(commitId);
-    for (let ref of oldRefMap.values()) {
+    for (const ref of oldRefMap.values()) {
       applyRef(ref, null);
     }
   }
@@ -65,10 +65,7 @@ function updateBackgroundRefs(commitId: number): void {
       const ref = backgroundSnapshotInstanceManager.getValueBySign(sign);
       if (ref) {
         // TODO: ref: support __REF_FIRE_IMMEDIATELY__
-        const v = newRefMap[sign]
-          && lynx.createSelectorQuery().selectUniqueID(
-            newRefMap[sign],
-          );
+        const v = newRefMap[sign] && lynx.createSelectorQuery().selectUniqueID(newRefMap[sign]);
         applyRef(ref, v);
       }
     }

package/runtime/src/snapshot.ts

@@ -6,7 +6,7 @@ import type { Worklet, WorkletRefImpl } from '@lynx-js/react/worklet-runtime/bin
 import type { BackgroundSnapshotInstance } from './backgroundSnapshot.js';
 import { ListUpdateInfoRecording, __pendingListUpdates, snapshotDestroyList } from './list.js';
 import { unref } from './snapshot/ref.js';
-import { SnapshotOperation, __globalSnapshotPatch } from './snapshotPatch.js';
+import { SnapshotOperation, __globalSnapshotPatch } from './lifecycle/patch/snapshotPatch.js';
 import { isDirectOrDeepEqual } from './utils.js';
 
 export const enum DynamicPartType {

package/runtime/src/worklet/functionCall.ts

@@ -11,7 +11,7 @@ import { IndexMap } from './indexMap.js';
 let resolveMap: IndexMap<(value: any) => void> | undefined;
 
 function initReturnValueListener(): void {
-  const context: RuntimeProxy = __JS__ ? lynx.getCoreContext() : lynx.getJSContext();
+  const context: RuntimeProxy = __JS__ ? lynx.getCoreContext!() : lynx.getJSContext!();
 
   resolveMap = new IndexMap();
   context.addEventListener(WorkletEvents.FunctionCallRet, onFunctionCallRet);

package/runtime/src/worklet/hmr.ts

@@ -1,7 +1,7 @@
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
-import { SnapshotOperation, __globalSnapshotPatch } from '../snapshotPatch.js';
+import { SnapshotOperation, __globalSnapshotPatch } from '../lifecycle/patch/snapshotPatch.js';
 
 const workletHashSet: Set<string> = /* @__PURE__ */ new Set();
 

package/runtime/src/worklet/runOnBackground.ts

@@ -28,12 +28,12 @@ function init() {
   }
 
   execIdMap = new WorkletExecIdMap();
-  lynx.getCoreContext().addEventListener(WorkletEvents.runOnBackground, runJSFunction);
-  lynx.getCoreContext().addEventListener(WorkletEvents.releaseBackgroundWorkletCtx, releaseBackgroundWorkletCtx);
+  lynx.getCoreContext!().addEventListener(WorkletEvents.runOnBackground, runJSFunction);
+  lynx.getCoreContext!().addEventListener(WorkletEvents.releaseBackgroundWorkletCtx, releaseBackgroundWorkletCtx);
 
   destroyTasks.push(() => {
-    lynx.getCoreContext().removeEventListener(WorkletEvents.runOnBackground, runJSFunction);
-    lynx.getCoreContext().removeEventListener(WorkletEvents.releaseBackgroundWorkletCtx, releaseBackgroundWorkletCtx);
+    lynx.getCoreContext!().removeEventListener(WorkletEvents.runOnBackground, runJSFunction);
+    lynx.getCoreContext!().removeEventListener(WorkletEvents.releaseBackgroundWorkletCtx, releaseBackgroundWorkletCtx);
     execIdMap = undefined;
   });
 }

package/runtime/src/worklet/workletRef.ts

@@ -89,7 +89,7 @@ export class MainThreadRef<T> extends WorkletRef<T> {
     super(initValue, 'main-thread');
     if (__JS__) {
       const id = this._id;
-      this._lifecycleObserver = lynx.getNativeApp().createJSObjectDestructionObserver(() => {
+      this._lifecycleObserver = lynx.getNativeApp().createJSObjectDestructionObserver?.(() => {
         lynx.getCoreContext?.().dispatchEvent({
           type: WorkletEvents.releaseWorkletRef,
           data: {