@sigx/lynx-runtime-main 0.2.4

package/dist/ops-apply.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Main Thread ops executor.
+ *
+ * Receives the flat-array ops buffer sent by the Background Thread via
+ * callLepusMethod('sigxPatchUpdate', { data: JSON.stringify(ops) }) and applies
+ * each operation using Lynx PAPI.
+ */
+/**
+ * SharedValue bridge state — registered wvids and last-published snapshots.
+ * The op handlers (`OP.REGISTER_AV_BRIDGE` / `OP.UNREGISTER_AV_BRIDGE` below)
+ * mutate these collections; `animated-bridge-mt.ts:flushAvBridgePublishes`
+ * reads them on every flush boundary to compute the diff to publish to BG.
+ */
+export declare const bridgedAvWvids: Set<number>;
+export declare const bridgedAvLastValues: Map<number, unknown>;
+export declare function setPlaceholder(parent: MainThreadElement, el: MainThreadElement): void;
+export declare function applyOps(ops: unknown[]): void;
+/** Reset module state — for testing and hot reload. */
+export declare function resetMainThreadState(): void;

package/dist/run-on-background-mt.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MT-side runOnBackground — dispatches function calls from the Main Thread
+ * to the Background Thread via 'Lynx.Sigx.RunOnBackground' events.
+ *
+ * Called inside extracted worklet bodies on the Main Thread. The SWC LEPUS
+ * pass leaves bare `runOnBackground(_jsFnK)` references in the registered
+ * worklet body; we install this implementation as `globalThis.runOnBackground`
+ * from `entry-main.ts` so the bare identifier resolves at runtime.
+ *
+ * Mirrors @lynx-js/react/runtime/lib/worklet/call/runOnMainThread (the dual
+ * direction) and vue-lynx's run-on-background-mt.ts. Sigx-namespaced event
+ * types so we don't conflict with upstream's own bridge if it ships in the
+ * same lynx process.
+ */
+interface JsFnHandle {
+    _jsFnId?: number;
+    _execId?: number;
+    _isFirstScreen?: boolean;
+    _error?: string;
+}
+export declare function runOnBackground(handle: JsFnHandle): (...args: unknown[]) => Promise<unknown>;
+export declare function resetRunOnBackgroundMtState(): void;
+export {};

package/dist/upstream/processGesture.d.ts

@@ -0,0 +1,28 @@
+interface GestureWorklet {
+    _wkltId: string;
+    _execId?: number;
+    _c?: Record<string, unknown>;
+    _jsFn?: Record<string, unknown>;
+    _workletType?: string;
+}
+interface BaseGesture {
+    __isSerialized: true;
+    type: number;
+    id: number;
+    callbacks: Record<string, GestureWorklet>;
+    waitFor?: BaseGesture[];
+    simultaneousWith?: BaseGesture[];
+    continueWith?: BaseGesture[];
+    config?: Record<string, unknown>;
+}
+interface ComposedGesture {
+    __isSerialized: true;
+    type: -1;
+    gestures: AnyGesture[];
+}
+type AnyGesture = BaseGesture | ComposedGesture;
+interface GestureOptions {
+    domSet?: boolean;
+}
+export declare function processGesture(dom: MainThreadElement, gesture: AnyGesture | undefined, oldGesture: AnyGesture | undefined, isFirstScreen: boolean, gestureOptions?: GestureOptions): void;
+export {};

package/dist/worklet-events.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Helpers for invoking worklets from the BG → MT bridge.
+ *
+ * Most of the worklet machinery (registry, ref map, event dispatch) is owned
+ * by `@lynx-js/react/worklet-runtime`, which is side-effect-imported from
+ * `entry-main.ts`. That runtime installs `globalThis.lynxWorkletImpl`,
+ * `globalThis.registerWorkletInternal`, and `globalThis.runWorklet`. Lynx
+ * native dispatches MT-routed events directly into `runWorklet`.
+ *
+ * What sigx-lynx still needs to provide is the `runOnMainThread` BG → MT call
+ * path: BG ships `{ wkltId, args }` over `callLepusMethod('sigxRunOnMT')`, the
+ * MT bridge handler in `entry-main.ts` calls `invokeWorklet()` here, and we
+ * look up the function in upstream's `_workletMap`.
+ */
+export interface WorkletPlaceholder {
+    _wkltId: string;
+    _c?: Record<string, unknown>;
+}
+/**
+ * Invoke a worklet by id with the given args. Used by the runOnMainThread
+ * bridge — event-driven worklets go through Lynx's native runWorklet path
+ * and never touch this function.
+ */
+export declare function invokeWorklet(wkltId: string, captured: Record<string, unknown> | undefined, args: unknown[]): unknown;
+/** Reset hook — for testing. The upstream worklet-runtime has its own state. */
+export declare function resetWorkletEvents(): void;

package/dist/worklet-refs.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Worklet ref registry — manages MainThreadRef state on the Main Thread.
+ *
+ * Each ref is identified by a worklet variable ID (wvid) assigned on the
+ * BG thread. When INIT_MT_REF arrives, we create a holder. When SET_MT_REF
+ * arrives, we set the holder's .current to the real element wrapper.
+ */
+interface WorkletRefHolder {
+    current: unknown;
+}
+/**
+ * Initialize a worklet ref on the Main Thread.
+ * Called when the BG thread sends INIT_MT_REF(wvid, initValue).
+ */
+export declare function initWorkletRef(wvid: number, initValue: unknown): void;
+/**
+ * Bind a worklet ref to a Main Thread element.
+ * Called when the BG thread sends SET_MT_REF(elementId, wvid).
+ * The ref's .current is set to an MTElementWrapper around the real element.
+ */
+export declare function bindWorkletRef(wvid: number, el: MainThreadElement): void;
+/**
+ * Get a worklet ref holder by wvid — used by worklet event handlers
+ * to access refs.
+ */
+export declare function getWorkletRef(wvid: number): WorkletRefHolder | undefined;
+/**
+ * Reset all worklet refs — for testing and hot reload.
+ */
+export declare function resetWorkletRefs(): void;
+export {};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@sigx/lynx-runtime-main",
+  "version": "0.2.4",
+  "description": "Main Thread (Lepus) entry and ops applier for SignalX Lynx renderer",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": true,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./entry-main": {
+      "import": "./dist/entry-main.js",
+      "types": "./dist/entry-main.d.ts"
+    },
+    "./install-hybrid-worklet": {
+      "import": "./dist/install-hybrid-worklet.js",
+      "types": "./dist/install-hybrid-worklet.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "sigx",
+    "lynx",
+    "main-thread"
+  ],
+  "author": "Andreas Ekdahl",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/signalxjs/lynx.git",
+    "directory": "packages/lynx-runtime-main"
+  },
+  "homepage": "https://github.com/signalxjs/lynx/tree/main/packages/lynx-runtime-main",
+  "bugs": {
+    "url": "https://github.com/signalxjs/lynx/issues"
+  },
+  "dependencies": {
+    "@lynx-js/react": "^0.120.0",
+    "@sigx/lynx-runtime-internal": "0.2.4"
+  },
+  "peerDependencies": {
+    "@lynx-js/types": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@lynx-js/types": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@lynx-js/types": "^3.7.0",
+    "@sigx/vite": "^0.4.3",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build && tsgo --emitDeclarationOnly",
+    "dev": "vite build --watch"
+  }
+}