@sigx/lynx-runtime-main 0.2.7 → 0.4.1

package/dist/animated-bridge-mt.js

@@ -0,0 +1,228 @@
+/**
+ * MT-side SharedValue bridge — publishes MT-thread mutations to BG.
+ *
+ * Diffs every registered SharedValue against its last-published snapshot
+ * and dispatches one batched `Lynx.Sigx.AvPublish` event per flush boundary
+ * with the changed `[wvid, value]` tuples. The BG side ingests these via
+ * `@sigx/lynx-runtime/src/animated-bridge.ts` and writes them into the
+ * mirror signal so any sigx `effect` reading `sv.value` re-runs.
+ *
+ * Bridge state (`bridgedAvWvids` / `bridgedAvLastValues`) lives in
+ * `ops-apply.ts` because the BG→MT op handlers mutate it; this module
+ * imports the references and reads them on every flush.
+ *
+ * Two flush hook points:
+ *   1. `ops-apply.ts` calls `flushAvBridgePublishes()` at its tail (covers
+ *      every BG-driven ops batch).
+ *   2. `installAvBridgeFlushHook()` wraps `globalThis.__FlushElementTree`
+ *      so spontaneous MT writes (e.g. a touchmove worklet that eventually
+ *      calls `setStyleProperties`) also trigger a publish on the same
+ *      tick the native tree flushes. Called once from `entry-main.ts`
+ *      after PAPI globals are present.
+ *
+ * Coalescing: `===` per-wvid diff. Identical writes are filtered. N writes
+ * within one flush window collapse to one BG event with N entries.
+ */
+import { bridgedAvWvids, bridgedAvLastValues } from './ops-apply.js';
+import { lookupMapper } from './animated-style-mappers.js';
+const AV_PUBLISH = 'Lynx.Sigx.AvPublish';
+/**
+ * Diff registered AVs against their last-published snapshots; dispatch one
+ * batched `Lynx.Sigx.AvPublish` event with all changed tuples. No-op when
+ * the bridge set is empty or when nothing has changed since the last call.
+ */
+export function flushAvBridgePublishes() {
+    if (bridgedAvWvids.size === 0)
+        return;
+    const impl = globalThis.lynxWorkletImpl;
+    const refMap = impl?._refImpl?._workletRefMap;
+    if (!refMap)
+        return;
+    let updates;
+    for (const wvid of bridgedAvWvids) {
+        const ref = refMap[wvid];
+        if (!ref)
+            continue;
+        const v = ref.current?.value;
+        if (v !== bridgedAvLastValues.get(wvid)) {
+            (updates ??= []).push([wvid, v]);
+            bridgedAvLastValues.set(wvid, v);
+        }
+    }
+    if (!updates)
+        return;
+    const lynxObj = globalThis.lynx;
+    const ctx = lynxObj?.getJSContext?.();
+    if (!ctx?.dispatchEvent)
+        return;
+    let data;
+    try {
+        data = JSON.stringify(updates);
+    }
+    catch (e) {
+        console.log('[sigx-mt] av-bridge: JSON.stringify failed:', String(e));
+        return;
+    }
+    ctx.dispatchEvent({ type: AV_PUBLISH, data });
+}
+const animatedStyleBindings = new Map();
+/**
+ * Register a binding (called from the OP.REGISTER_AV_STYLE_BINDING op
+ * handler in `ops-apply.ts`). Initializes `lastValue` to a sentinel so the
+ * first flush always applies the mapper, even when the AV is at its initial.
+ */
+export function registerAnimatedStyleBinding(bindingId, elementWvid, avWvid, mapperName, params) {
+    // Sentinel — guaranteed not to equal any user value, so the first flush
+    // applies the mapper regardless of whether the AV ever gets written.
+    const sentinel = {};
+    animatedStyleBindings.set(bindingId, {
+        elementWvid,
+        avWvid,
+        mapperName,
+        params,
+        lastValue: sentinel,
+    });
+}
+export function unregisterAnimatedStyleBinding(bindingId) {
+    animatedStyleBindings.delete(bindingId);
+}
+export function resetAnimatedStyleBindings() {
+    animatedStyleBindings.clear();
+}
+export function animatedStyleBindingCount() {
+    return animatedStyleBindings.size;
+}
+/**
+ * For each element with at least one *dirty* binding (AV value changed since
+ * the last apply), re-run **all** of that element's bindings, merge their
+ * mapper outputs, and apply the result with a single `setStyleProperties`
+ * call. Called from the wrapped `__FlushElementTree` *before* the native
+ * tree flush.
+ *
+ * Why "all bindings on a dirty element" rather than "only changed bindings":
+ *   - Multiple bindings on the same element can write the same style key
+ *     (e.g. `translateX` + `translateY` both produce `transform`). If we
+ *     applied only the changed ones, the unchanged-binding's contribution
+ *     would be lost and the element would visibly snap. By re-running every
+ *     binding on the dirty element and merging, all contributions land in
+ *     the same `setStyleProperties` call.
+ *
+ * Merge semantics:
+ *   - `transform` values from multiple bindings *concatenate* in registration
+ *     order (e.g. `translateX(50px)` + `translateY(20px)` ->
+ *     `translateX(50px) translateY(20px)`).
+ *   - All other keys merge by last-write-wins; a binding registered later on
+ *     the same element overwrites an earlier binding's same-key output.
+ *
+ * Skip cases (silent, by design):
+ *   - AV ref missing in `_workletRefMap` (race with unregister).
+ *   - Element ref's `current` is null (component not yet mounted, or
+ *     unmounted before the binding's UNREGISTER op landed).
+ *   - Mapper name not registered (typo or missing custom registration).
+ */
+export function flushAnimatedStyleBindings() {
+    if (animatedStyleBindings.size === 0)
+        return;
+    const impl = globalThis.lynxWorkletImpl;
+    const refMap = impl?._refImpl?._workletRefMap;
+    if (!refMap)
+        return;
+    // Phase 1 — find which elements have at least one dirty binding. Update
+    // each binding's lastValue so the next flush only re-applies on further
+    // change. Skip bindings whose AV ref is missing.
+    let dirtyElements;
+    for (const binding of animatedStyleBindings.values()) {
+        const avRef = refMap[binding.avWvid];
+        if (!avRef)
+            continue;
+        const v = avRef.current?.value;
+        if (v === binding.lastValue)
+            continue;
+        binding.lastValue = v;
+        (dirtyElements ??= new Set()).add(binding.elementWvid);
+    }
+    if (!dirtyElements)
+        return;
+    // Phase 2 — for each dirty element, run *all* its bindings and merge the
+    // outputs into one style object. Iteration order over the Map is insertion
+    // order, which equals registration order — so transform concatenations
+    // come out in the order the user registered them.
+    const merged = new Map();
+    for (const binding of animatedStyleBindings.values()) {
+        if (!dirtyElements.has(binding.elementWvid))
+            continue;
+        const avRef = refMap[binding.avWvid];
+        if (!avRef)
+            continue;
+        const v = avRef.current?.value;
+        const mapper = lookupMapper(binding.mapperName);
+        if (!mapper)
+            continue;
+        let out;
+        try {
+            out = mapper(v, binding.params);
+        }
+        catch (e) {
+            console.log('[sigx-mt] av-style mapper threw:', binding.mapperName, String(e));
+            continue;
+        }
+        let acc = merged.get(binding.elementWvid);
+        if (!acc) {
+            acc = {};
+            merged.set(binding.elementWvid, acc);
+        }
+        for (const k in out) {
+            if (k === 'transform' && typeof acc.transform === 'string') {
+                acc.transform = `${acc.transform} ${String(out.transform)}`;
+            }
+            else {
+                acc[k] = out[k];
+            }
+        }
+    }
+    // Phase 3 — one setStyleProperties per dirty element.
+    for (const [elementWvid, styleObj] of merged) {
+        const elRef = refMap[elementWvid];
+        const el = elRef?.current;
+        if (!el?.setStyleProperties)
+            continue;
+        try {
+            el.setStyleProperties(styleObj);
+        }
+        catch (e) {
+            console.log('[sigx-mt] av-style setStyleProperties threw:', String(e));
+        }
+    }
+}
+const INSTALLED = Symbol.for('sigx.avBridgeFlushHookInstalled');
+/**
+ * Wrap `globalThis.__FlushElementTree` once so every flush also runs the AV
+ * bridge publish step. Idempotent — safe to call across hot reloads. Test
+ * setups that `vi.stubGlobal('__FlushElementTree', ...)` AFTER this hook
+ * installs will replace our wrapper, which is the correct behavior for
+ * unit tests that drive `flushAvBridgePublishes` directly.
+ */
+export function installAvBridgeFlushHook() {
+    const g = globalThis;
+    if (g[INSTALLED])
+        return;
+    const original = g['__FlushElementTree'];
+    if (typeof original !== 'function')
+        return;
+    g[INSTALLED] = true;
+    g['__FlushElementTree'] = function wrappedFlushElementTree(...args) {
+        try {
+            flushAvBridgePublishes();
+        }
+        catch (e) {
+            console.log('[sigx-mt] av-bridge flush threw:', String(e));
+        }
+        try {
+            flushAnimatedStyleBindings();
+        }
+        catch (e) {
+            console.log('[sigx-mt] av-style bindings flush threw:', String(e));
+        }
+        return original.apply(this, args);
+    };
+}

package/dist/animated-style-mappers.js

@@ -0,0 +1,154 @@
+/**
+ * MT-side mapper registry for `useAnimatedStyle`.
+ *
+ * Maps a `SharedValue`'s current scalar to a partial style object that the
+ * binding flush passes to `setStyleProperties` on the bound element. Keyed by
+ * a string name (`'translateX'`, `'scale'`, ...) so the SWC worklet transform
+ * can capture the selection trivially: a string is a primitive `_c` value
+ * with no special lifting required (unlike arbitrary functions, which can't
+ * be captured into a worklet's closure).
+ *
+ * Custom mappers can be registered via `registerMapper(name, fn)` from MT
+ * code (e.g. a `'main thread'`-marked module body in a user app). BG-side
+ * `useAnimatedStyle` validates the name only against the type union; a
+ * lookup mismatch on MT is a silent no-op at flush time.
+ *
+ * Param shapes are mapper-specific. The `MapperParams` type in
+ * `@sigx/lynx-runtime-internal` is the single source of truth — both
+ * BG-side `useAnimatedStyle` and the MT runtime import it from there.
+ *
+ * Range mapping: `translateX` / `translateY` / `scale` / `opacity` accept
+ * either their linear `factor`/`offset` shape or a `RangeParams` shape
+ * (`{ inputRange, outputRange, extrapolate? }`). The mapper picks the branch
+ * by looking for `inputRange` on the params.
+ */
+function isRangeParams(p) {
+    return (typeof p === 'object' && p !== null
+        && 'inputRange' in p
+        && 'outputRange' in p);
+}
+/**
+ * Linear interpolation across a multi-stop range. Locates the input segment
+ * via simple linear scan (inputRange is small in practice — typically 2-4
+ * stops) and lerps within it. Out-of-range behavior controlled by
+ * `extrapolate`: `'clamp'` (default) caps at endpoint outputs; `'identity'`
+ * extends linearly using the slope of the nearest segment.
+ */
+function interpolateLinear(v, inputRange, outputRange, extrapolate = 'clamp') {
+    const n = inputRange.length;
+    if (n < 2)
+        return outputRange[0] ?? v;
+    if (v <= inputRange[0]) {
+        if (extrapolate === 'clamp')
+            return outputRange[0];
+        const dx = inputRange[1] - inputRange[0];
+        const dy = outputRange[1] - outputRange[0];
+        return outputRange[0] + (v - inputRange[0]) * (dy / dx);
+    }
+    if (v >= inputRange[n - 1]) {
+        if (extrapolate === 'clamp')
+            return outputRange[n - 1];
+        const dx = inputRange[n - 1] - inputRange[n - 2];
+        const dy = outputRange[n - 1] - outputRange[n - 2];
+        return outputRange[n - 1] + (v - inputRange[n - 1]) * (dy / dx);
+    }
+    for (let i = 1; i < n; i++) {
+        if (v <= inputRange[i]) {
+            const t = (v - inputRange[i - 1]) / (inputRange[i] - inputRange[i - 1]);
+            return outputRange[i - 1] + t * (outputRange[i] - outputRange[i - 1]);
+        }
+    }
+    return outputRange[n - 1];
+}
+const mtMappers = {
+    translateX: (v, p) => {
+        if (isRangeParams(p)) {
+            const out = interpolateLinear(v, p.inputRange, p.outputRange, p.extrapolate);
+            return { transform: `translateX(${out}px)` };
+        }
+        const factor = p?.factor ?? 1;
+        return { transform: `translateX(${v * factor}px)` };
+    },
+    translateY: (v, p) => {
+        if (isRangeParams(p)) {
+            const out = interpolateLinear(v, p.inputRange, p.outputRange, p.extrapolate);
+            return { transform: `translateY(${out}px)` };
+        }
+        const factor = p?.factor ?? 1;
+        return { transform: `translateY(${v * factor}px)` };
+    },
+    translate: (v, p) => {
+        const params = p ?? {};
+        const fx = params.factorX ?? 1;
+        const fy = params.factorY ?? 1;
+        const xy = v;
+        return { transform: `translate(${xy.x * fx}px, ${xy.y * fy}px)` };
+    },
+    scale: (v, p) => {
+        if (isRangeParams(p)) {
+            const out = interpolateLinear(v, p.inputRange, p.outputRange, p.extrapolate);
+            return { transform: `scale(${out})` };
+        }
+        const offset = p?.offset ?? 0;
+        return { transform: `scale(${v + offset})` };
+    },
+    opacity: (v, p) => {
+        if (isRangeParams(p)) {
+            const raw = interpolateLinear(v, p.inputRange, p.outputRange, p.extrapolate);
+            const out = Math.max(0, Math.min(1, raw));
+            return { opacity: String(out) };
+        }
+        const params = p ?? {};
+        const factor = params.factor ?? 1;
+        const offset = params.offset ?? 0;
+        const out = Math.max(0, Math.min(1, v * factor + offset));
+        return { opacity: String(out) };
+    },
+    rotate: (v) => ({ transform: `rotate(${v}deg)` }),
+    paddingTop: (v, p) => ({ paddingTop: `${linearOrRange(v, p)}px` }),
+    paddingRight: (v, p) => ({ paddingRight: `${linearOrRange(v, p)}px` }),
+    paddingBottom: (v, p) => ({ paddingBottom: `${linearOrRange(v, p)}px` }),
+    paddingLeft: (v, p) => ({ paddingLeft: `${linearOrRange(v, p)}px` }),
+    marginTop: (v, p) => ({ marginTop: `${linearOrRange(v, p)}px` }),
+    marginRight: (v, p) => ({ marginRight: `${linearOrRange(v, p)}px` }),
+    marginBottom: (v, p) => ({ marginBottom: `${linearOrRange(v, p)}px` }),
+    marginLeft: (v, p) => ({ marginLeft: `${linearOrRange(v, p)}px` }),
+};
+function linearOrRange(v, p) {
+    if (isRangeParams(p)) {
+        return interpolateLinear(v, p.inputRange, p.outputRange, p.extrapolate);
+    }
+    const factor = p?.factor ?? 1;
+    return v * factor;
+}
+/**
+ * Look up a registered mapper by name. Returns `undefined` if the name
+ * isn't registered — the binding flush treats that as a no-op.
+ */
+export function lookupMapper(name) {
+    return mtMappers[name];
+}
+/**
+ * Register a custom MT-side mapper. Idempotent on (name, fn) — last
+ * registration wins for the same name. Intended for `'main thread'`-marked
+ * user modules that ship project-specific styling math.
+ */
+export function registerMapper(name, mapper) {
+    mtMappers[name] = mapper;
+}
+/**
+ * Reset hook — drops every custom mapper, reseats the built-ins. Used by
+ * the MT-side resetMainThreadState path (HMR / tests).
+ */
+const BUILTIN_NAMES = new Set([
+    'translateX', 'translateY', 'translate', 'scale', 'opacity', 'rotate',
+    'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft',
+    'marginTop', 'marginRight', 'marginBottom', 'marginLeft',
+]);
+export function resetMappers() {
+    for (const k in mtMappers) {
+        if (!BUILTIN_NAMES.has(k)) {
+            delete mtMappers[k];
+        }
+    }
+}

package/dist/element-registry.js

@@ -0,0 +1,16 @@
+/**
+ * Element registry — maps BG-thread ShadowElement IDs to Lynx Main Thread
+ * element handles.
+ */
+/** Map from BG-thread ShadowElement id to Lynx Main Thread element handle */
+export const elements = new Map();
+/**
+ * PAPI unique ID of the root PageElement.
+ * Passed as `parentComponentUniqueId` to element creation PAPI calls.
+ * `__SetCSSId` sets `css_style_sheet_manager_` directly on each element,
+ * so CSS rendering works without a ComponentElement ancestor.
+ */
+export let pageUniqueId = 1;
+export function setPageUniqueId(id) {
+    pageUniqueId = id;
+}

package/dist/entry-main.js

@@ -1 +1,229 @@
-import "./entry-main-CBM2DHsU.js";
+/**
+ * Main Thread (Lepus) bootstrap entry.
+ *
+ * Injected by @sigx/lynx-plugin as the sole content of the main-thread bundle.
+ * Sets up:
+ *   - globalThis.processData   — required by Lynx Lepus runtime (data processor)
+ *   - globalThis.renderPage    — creates the Lynx page root (id=1)
+ *   - globalThis.updatePage    — no-op stub (required by Lynx Lepus runtime)
+ *   - globalThis.sigxPatchUpdate — receives ops from Background Thread
+ */
+import { elements, setPageUniqueId } from './element-registry.js';
+import { applyOps, resetMainThreadState, setPlaceholder } from './ops-apply.js';
+import { invokeWorklet } from './worklet-events.js';
+import { runOnBackground } from './run-on-background-mt.js';
+import { installAvBridgeFlushHook } from './animated-bridge-mt.js';
+const g = globalThis;
+// CRITICAL: SystemInfo must be set BEFORE the @lynx-js/react/worklet-runtime
+// IIFE evaluates (it reads SystemInfo as a free identifier at init time).
+// lynx-plugin orders MT entries [entry-main, worklet-runtime, ...userImports]
+// so this module body runs before the worklet-runtime entry. Keeping the
+// install in module body (not an import) prevents vite from hoisting it.
+if (g['SystemInfo'] === undefined) {
+    const lynxObj = g['lynx'];
+    g['SystemInfo'] = lynxObj?.SystemInfo ?? {};
+}
+/** PAGE_ROOT_ID must match the value used in the BG-thread renderer */
+const PAGE_ROOT_ID = 1;
+// Lynx Lepus runtime requires globalThis.processData to be set.
+// It is called to transform initial data before renderPage runs.
+// For sigx we have no data processors, so just pass data through.
+g['processData'] = function (data, _processorName) {
+    return data ?? {};
+};
+// Lynx calls renderPage on the Main Thread first (before Background JS runs).
+// We create the root page element and store it as id=1 so Background ops that
+// target the root can resolve it correctly.
+g['renderPage'] = function (_data) {
+    resetMainThreadState();
+    const page = __CreatePage('0', 0);
+    __SetCSSId([page], 0);
+    setPageUniqueId(__GetElementUniqueID(page));
+    elements.set(PAGE_ROOT_ID, page);
+    // Append a placeholder __CreateView under the page root so the host sees a
+    // non-empty tree immediately. Without this, the host's "no UI within timeout"
+    // check fires before the BG thread's first ops batch arrives, producing a
+    // phantom USER_RUNTIME_ERROR. The placeholder is removed on the first
+    // applyOps() call (see ops-apply.ts).
+    const placeholder = __CreateView(__GetElementUniqueID(page));
+    __SetCSSId([placeholder], 0);
+    __AppendElement(page, placeholder);
+    setPlaceholder(page, placeholder);
+    __FlushElementTree(page);
+};
+// Lynx may call updatePage / updateGlobalProps after data changes.
+// We have no data binding on Main Thread, so these are no-ops.
+g['updatePage'] = function (_data) {
+    // no-op
+};
+g['updateGlobalProps'] = function (_data) {
+    // no-op
+};
+// Called by the BG Thread via callLepusMethod('sigxHotReload', {}) when a
+// webpack HMR update is about to be applied. Resets the Main Thread element
+// registry and re-creates the page root so the next sigxPatchUpdate batch
+// builds on a clean tree.
+//
+// NOTE: With component-level HMR, component file changes are self-accepted
+// by the HMR loader and patched in-place on the BG thread — this handler
+// is NOT involved. It exists as a safety net for future non-component
+// reload scenarios (e.g., if a host decides to send sigxHotReload
+// explicitly). See docs/hmr-investigation.md.
+g['sigxHotReload'] = function () {
+    const existingPage = elements.get(PAGE_ROOT_ID);
+    resetMainThreadState();
+    const page = existingPage ?? __CreatePage('0', 0);
+    __SetCSSId([page], 0);
+    setPageUniqueId(__GetElementUniqueID(page));
+    elements.set(PAGE_ROOT_ID, page);
+    const placeholder = __CreateView(__GetElementUniqueID(page));
+    __SetCSSId([placeholder], 0);
+    __AppendElement(page, placeholder);
+    setPlaceholder(page, placeholder);
+    __FlushElementTree(page);
+};
+// Called by the BG Thread via callLepusMethod('sigxApplyMtHotUpdate', { code }).
+// `code` is the concatenated `registerWorkletInternal(...)` calls extracted
+// from the matching `main__main-thread.<hash>.hot-update.js` file. Eval'd in
+// the existing realm so new content-hash worklet IDs land in the live
+// `_workletMap` before the user taps a re-rendered button.
+//
+// See `lynx-runtime/src/mt-hmr-bridge.ts` for the BG-side fetch + forward.
+g['sigxApplyMtHotUpdate'] = function ({ code }) {
+    if (!code)
+        return;
+    try {
+        new Function(code)();
+    }
+    catch (e) {
+        console.log('[sigx-mt] sigxApplyMtHotUpdate eval failed:', String(e));
+    }
+};
+// Called by the BG Thread via callLepusMethod('sigxPatchUpdate', { data }).
+g['sigxPatchUpdate'] = function ({ data }) {
+    let ops;
+    try {
+        ops = JSON.parse(data);
+    }
+    catch (e) {
+        console.log('[sigx-mt] sigxPatchUpdate JSON parse failed:', String(e));
+        return;
+    }
+    try {
+        applyOps(ops);
+    }
+    catch (e) {
+        console.log('[sigx-mt] applyOps threw:', String(e));
+    }
+    // applyOps() already calls __FlushElementTree() at its tail.
+};
+// ---------------------------------------------------------------------------
+// runOnMainThread bridge (BG → MT worklet invocation)
+//
+// Called by the BG Thread via callLepusMethod('sigxRunOnMT',
+// { wkltId, args, captured }). When `captured` is supplied, route through
+// upstream's `runWorklet({_wkltId, _c}, args)` so its `I()` walker hydrates
+// the placeholders inside `_c` (resolves nested `{_wkltId}` worklet refs to
+// callable functions and `{_wvid}` ref placeholders to live MainThreadRefs
+// from `_workletRefMap`). This matches the path SET_WORKLET_EVENT uses for
+// JSX-attached MT handlers, and is what makes captures like
+// `runOnMainThread(() => { 'main thread'; withSpring(sv, 0); })` work
+// (`withSpring` is a worklet placeholder that needs hydration before the
+// destructure-and-call inside the body).
+//
+// `invokeWorklet` is kept as a fallback for the `captured === undefined`
+// case (no captures to hydrate) and for direct-from-MT callers that already
+// hand over a hydrated ctx.
+// ---------------------------------------------------------------------------
+/**
+ * Deep-clone a value into a fresh tree whose every object has
+ * `Object.prototype`.
+ *
+ * Why: PrimJS's `JSON.parse` produces null-prototype objects (a prototype-
+ * pollution safety measure that V8 / SpiderMonkey don't apply). Upstream's
+ * worklet runtime (`@lynx-js/react@0.121+`'s `workletRuntime.js`) walks
+ * the captured `_c`, identifies worklet placeholders by `'_wkltId' in
+ * subObj`, and then calls `new WeakRef(subObj)`. PrimJS's `WeakRef` rejects
+ * null-prototype objects with `TypeError: WeakRef: target must be an
+ * object`, so the worklet body never runs.
+ *
+ * `Object.setPrototypeOf` is a silent no-op on PrimJS's JSON.parse output
+ * (the proto slot is locked even with `isExtensible: true`), so the only
+ * way to get an `Object.prototype`-prototyped object is to rebuild it via
+ * `{}` literal. A fresh object literal always has `Object.prototype` by
+ * spec, so deep-cloning the captured tree produces a fully WeakRef-able
+ * shape that's semantically identical for the worklet body.
+ *
+ * JSON.parse output is acyclic by construction, so no cycle detection
+ * needed. Arrays handled separately to keep `Array.isArray` true downstream.
+ */
+function rebuildWithObjectPrototype(value) {
+    if (typeof value !== 'object' || value === null)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(rebuildWithObjectPrototype);
+    }
+    // Use `Object.defineProperty` (not `out[k] = ...`) so a `__proto__` key in
+    // the captured payload doesn't trigger the prototype setter on `out` and
+    // re-null the prototype we just gave it. Belt-and-braces against accidental
+    // prototype pollution; in practice `_c` is shaped by `sanitizeCaptured` on
+    // BG and shouldn't carry `__proto__`, but the guarantee is cheap.
+    const out = {};
+    for (const k of Object.keys(value)) {
+        Object.defineProperty(out, k, {
+            value: rebuildWithObjectPrototype(value[k]),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return out;
+}
+g['sigxRunOnMT'] = function ({ wkltId, args, captured }, callback) {
+    const argsArr = args ?? [];
+    let result;
+    const runWorkletFn = globalThis['runWorklet'];
+    if (captured && typeof runWorkletFn === 'function') {
+        // PrimJS quirk: `JSON.parse` produces null-prototype objects whose proto
+        // slot is locked (`setPrototypeOf` is a silent no-op). Upstream's worklet
+        // runtime calls `new WeakRef(subObj)` on every nested placeholder, and
+        // PrimJS's `WeakRef` rejects null-prototype objects → animations no-op.
+        //
+        // Rebuild the captured tree from scratch via object literals — every
+        // `{}` has `Object.prototype` by construction. Semantically identical
+        // for the worklet body; only upstream's `WeakRef` / `instanceof` checks
+        // are affected, which now succeed.
+        const fixedCaptured = rebuildWithObjectPrototype(captured);
+        try {
+            result = runWorkletFn({ _wkltId: wkltId, _c: fixedCaptured }, argsArr);
+        }
+        catch (e) {
+            console.log('[sigx-mt] sigxRunOnMT worklet threw:', String(e), 'wkltId=', wkltId);
+            result = undefined;
+        }
+    }
+    else {
+        result = invokeWorklet(wkltId, captured, argsArr);
+    }
+    if (typeof callback === 'function') {
+        callback(result);
+    }
+};
+// MT-side worklet event dispatch is handled natively: the SET_WORKLET_EVENT
+// op handler in ops-apply.ts calls __AddEvent with `{ type: 'worklet', value }`,
+// and Lynx native routes those to globalThis.runWorklet (installed by the
+// @lynx-js/react/worklet-runtime side-effect import above).
+// Install the SharedValue bridge flush hook. Wraps __FlushElementTree so
+// every native flush also runs flushAvBridgePublishes (covers the
+// touchmove path: worklet writes SharedValue → calls setStyleProperties →
+// upstream queues a __FlushElementTree microtask → our wrapper publishes
+// diffed SharedValues to BG before the tree flush). Idempotent.
+installAvBridgeFlushHook();
+// ---------------------------------------------------------------------------
+// runOnBackground bridge (MT → BG worklet invocation)
+//
+// SWC's LEPUS pass leaves bare `runOnBackground(_jsFnK)` references in the
+// extracted worklet body — they resolve as a free identifier. Install our
+// MT-side dispatcher as a global so those calls reach the BG event bus.
+// ---------------------------------------------------------------------------
+g['runOnBackground'] = runOnBackground;