@sigx/lynx-runtime 0.2.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# @sigx/lynx-runtime
+
+Background-thread renderer for [SignalX](https://github.com/signalxjs) on Lynx. Translates sigx component output into the BG → MT op stream that drives the native render tree.
+
+> Most apps should depend on [`@sigx/lynx`](../lynx) instead, which re-exports this package's public surface alongside `@sigx/reactivity` and `@sigx/runtime-core` for a single import path.
+
+## Responsibilities
+
+- **`render` / `lynxMount`** — boot the BG renderer against a `lynx.getJSContext()`-style host.
+- **`nodeOps`** — sigx `RuntimeRenderer` adapter that turns vnode operations into op-queue entries.
+- **Op queue** — `pushOp`, `scheduleFlush`, `takeOps`, `flushNow` — the wire protocol carrying renders from BG to MT.
+- **Main-thread refs** — `MainThreadRef`, `useMainThreadRef` — the BG-side handle whose `.current` value lives on the main thread; the build pipeline serializes these into worklet captures via their `_wvid`.
+- **Cross-thread bridges** — `runOnMainThread` (BG→MT one-shot), `runOnBackground` (MT→BG dispatch handle), `transformToWorklet` (handle → JsFn marshal).
+- **AnimatedValue BG sink** — `registerBgSink`, `unregisterBgSink`, `ingestAvPublishes` — receive MT-published `AnimatedValue` writes into a `signal`-backed mirror so `effect(() => av.value)` re-runs reactively. The producer side lives in [`@sigx/gestures`](../gestures); the MT side lives in [`@sigx/lynx-runtime-main`](../lynx-runtime-main).
+- **JSX types** — `MainThread`, `Define`, `ViewAttributes`, etc.
+
+## Wire protocol
+
+Ops are flat-array tuples produced on BG and consumed on MT. The op codes (`CREATE`, `INSERT`, `SET_STYLE`, `SET_WORKLET_EVENT`, `INIT_MT_REF`, `REGISTER_AV_BRIDGE`, ...) are defined in [`@sigx/lynx-runtime-internal`](../lynx-runtime-internal) so both sides stay in sync.
+
+A typical batch:
+
+```ts
+[OP.CREATE, 1, 'view',
+ OP.SET_STYLE, 1, { width: '100px', height: '100px' },
+ OP.INSERT, 0, 1, -1,
+ OP.INIT_MT_REF, 7, null,
+ OP.SET_MT_REF, 1, 7]
+```
+
+Serialized to JSON, shipped via `lynx.getNativeApp().callLepusMethod('sigxPatchUpdate', { data })`, applied by the MT runtime in `@sigx/lynx-runtime-main`.
+
+## Background event bridge
+
+`bg-bridge.ts` listens on `lynx.getCoreContext()` for two MT-originated event types:
+
+- `Lynx.Sigx.PublishEvent` — hybrid worklet → BG event handler dispatch (`<view bindtap={…}>` style).
+- `Lynx.Sigx.AvPublish` — coalesced `AnimatedValue` write batches; routed into `ingestAvPublishes`.
+
+## License
+
+MIT

package/dist/animated/animated-value.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @deprecated since Phase 2.8 — renamed to `SharedValue` to reflect that the
+ * primitive is a general MT-writeable, BG-observable cross-thread value, not
+ * an animation-specific construct. Animation is one customer; scroll, sensors,
+ * and gestures are equally first-class consumers.
+ *
+ * Import from `@sigx/lynx` directly:
+ *
+ *   - `useAnimatedValue` → `useSharedValue`
+ *   - `AnimatedValue`     → `SharedValue`
+ *   - `AnimatedValueState` → `SharedValueState`
+ *
+ * The old names continue to work via these re-exports for one minor cycle.
+ */
+export { SharedValue as AnimatedValue, useSharedValue as useAnimatedValue, } from './shared-value.js';
+export type { SharedValueState as AnimatedValueState } from './shared-value.js';

package/dist/animated/shared-value.d.ts

@@ -0,0 +1,67 @@
+import type { PrimitiveSignal } from '@sigx/reactivity';
+import { MainThreadRef } from '../main-thread-ref.js';
+/**
+ * Internal envelope shape stored under `MainThreadRef.current`. Wrapping the
+ * value in `{ value: T }` (rather than a bare `T`) lets MT worklets mutate
+ * the value without breaking ref identity, and leaves room to extend with
+ * derived state later (e.g. velocity) without changing the public type.
+ */
+export interface SharedValueState<T> {
+    value: T;
+}
+/**
+ * MT-writeable, BG-readable cross-thread value with sigx reactive tracking.
+ *
+ * **Not animation-specific.** Animation is one customer (see `@sigx/motion`),
+ * gestures is another (`<Draggable translateX={sv} />`), scroll is another
+ * (`useScrollViewOffset`). Anywhere fast-or-frequent state lives natively on
+ * MT and you want BG to observe it reactively, this is the primitive.
+ *
+ * **MT side** — inside `'main thread'` worklets, mutate via `sv.current.value
+ * = newValue`. The MainThreadRef machinery makes the mutation stick across
+ * worklet invocations on the same wvid; the bridge picks up the new value on
+ * the next `__FlushElementTree` boundary.
+ *
+ * **BG side** — read via `sv.value` to get the latest published snapshot.
+ * Sigx tracking applies, so an `effect(() => console.log(sv.value))` re-runs
+ * whenever an MT publish ingests a new value. Writes from BG are read-only;
+ * dev-mode warns to point users back at the MT path.
+ *
+ * The class extends `MainThreadRef<{value:T}>` so that BG-side serialization
+ * (`nodeOps.ts:sanitizeCaptured`) recognizes it as a worklet ref and ships
+ * `{_wvid, _initValue}` over the wire to the MT bundle.
+ *
+ * @example
+ * ```tsx
+ * const tx = useSharedValue(0);
+ *
+ * <Draggable translateX={tx} />
+ * <text>x = {tx.value}</text>   // BG-reactive, updates per drag frame
+ * ```
+ */
+export declare class SharedValue<T = number> extends MainThreadRef<SharedValueState<T>> {
+    /** @internal — populated by `useSharedValue`. Reads here back the BG signal. */
+    private _bgSignal;
+    constructor(initial: T);
+    /** @internal */
+    _bind(sig: PrimitiveSignal<T>): void;
+    /**
+     * BG-side reactive read. Returns the latest snapshot published by the MT
+     * bridge (or the initial value before any publish has occurred).
+     */
+    get value(): T;
+    set value(_v: T);
+}
+/**
+ * Allocate a `SharedValue<T>` whose MT-side mutations are observable on the
+ * BG thread via sigx reactivity. Bind it to a component prop or read its
+ * `.value` from a BG `effect`.
+ *
+ * Lifecycle:
+ *   - On allocate: pushes `INIT_MT_REF` (creates the MT-side refMap holder)
+ *     and `REGISTER_AV_BRIDGE` (tells MT to track this wvid in its diff/
+ *     publish pass). Allocates a BG-side signal mirror keyed by wvid.
+ *   - On the owning component's unmount: pushes `UNREGISTER_AV_BRIDGE` and
+ *     `RELEASE_MT_REF`, drops the BG signal.
+ */
+export declare function useSharedValue<T = number>(initial: T): SharedValue<T>;

package/dist/animated/use-animated-style.d.ts

@@ -0,0 +1,37 @@
+import type { MainThreadRef } from '../main-thread-ref.js';
+import type { MainThread } from '../jsx.js';
+import type { BuiltinMapperName, MapperParams } from '@sigx/lynx-runtime-internal';
+import type { SharedValue } from './shared-value.js';
+export type { BuiltinMapperName, MapperParams };
+/** Reset hook for tests. */
+export declare function resetAnimatedStyleBindingIds(): void;
+/**
+ * Bind a `MainThreadRef`'s element style to a `SharedValue` via a named
+ * mapper. The MT-side runtime applies the mapper's output via
+ * `setStyleProperties` on every flush boundary where the SharedValue's value changed.
+ *
+ * The mapper runs on the **Main Thread** with no thread crossing per frame —
+ * the only inputs are the SharedValue's value (already on MT) and the `params` shipped
+ * once in the registration op. Because mappers are looked up by *name*, the
+ * SWC worklet transform doesn't have to capture a function reference (which
+ * it can't), so this fits the existing worklet pipeline cleanly.
+ *
+ * Multiple bindings on the same element compose into a single
+ * `setStyleProperties` call per flush. `transform` outputs concatenate in
+ * registration order (e.g. `translateX(50px) translateY(20px)`); other style
+ * keys merge by last-write-wins. When ANY binding on an element is dirty,
+ * ALL of that element's bindings re-run so partial outputs don't drop the
+ * unchanged-axis contribution.
+ *
+ * @example Ghost follower at 0.5×
+ * ```tsx
+ * const tx = useSharedValue(0);
+ * const ghostRef = useMainThreadRef<MainThread.Element | null>(null);
+ *
+ * useAnimatedStyle(ghostRef, tx, 'translateX', { factor: 0.5 });
+ *
+ * <Draggable translateX={tx} />
+ * <view main-thread:ref={ghostRef} style={...} />
+ * ```
+ */
+export declare function useAnimatedStyle<N extends BuiltinMapperName>(elRef: MainThreadRef<MainThread.Element | null>, sv: SharedValue<unknown>, mapperName: N, params?: MapperParams[N]): void;

package/dist/animated-bridge.d.ts

@@ -0,0 +1,45 @@
+/**
+ * BG-side SharedValue bridge — receives MT-thread publishes.
+ *
+ * Maintains a `wvid → signal<T>` registry. The MT-side bridge in
+ * `@sigx/lynx-runtime-main/animated-bridge-mt.ts` dispatches batched
+ * `Lynx.Sigx.AvPublish` events with `[wvid, value]` tuples; `bg-bridge.ts`
+ * routes them through `ingestAvPublishes()` here, which writes each new
+ * value into the corresponding signal. Sigx reactivity tracking then re-runs
+ * any `effect` that read `sv.value` on BG.
+ *
+ * Producer: the `useSharedValue` hook in `@sigx/lynx` allocates the
+ * BG-side signal via `registerBgSink(wvid, initial)` and tears it down via
+ * `unregisterBgSink(wvid)` on component unmount.
+ *
+ * Naming note: the wire-format ops (`REGISTER_AV_BRIDGE`, `UNREGISTER_AV_BRIDGE`,
+ * `Lynx.Sigx.AvPublish`) keep their original `Av` prefix as infrastructure
+ * constants. The user-facing primitive renamed from `AnimatedValue` to
+ * `SharedValue` in Phase 2.8.
+ */
+import { type PrimitiveSignal } from '@sigx/reactivity';
+/**
+ * Allocate a BG-side signal mirror for the given wvid. Returns the signal so
+ * the caller can read it via `.value` — sigx tracking applies as usual.
+ *
+ * Idempotent on the wvid: if a signal is already registered, returns the
+ * existing one without resetting its value (avoids losing in-flight publishes
+ * during HMR-triggered re-registration).
+ */
+export declare function registerBgSink<T>(wvid: number, initial: T): PrimitiveSignal<T>;
+/**
+ * Drop the BG-side signal for this wvid. Called on component unmount.
+ * Subsequent `ingestPublish` entries for this wvid become no-ops.
+ */
+export declare function unregisterBgSink(wvid: number): void;
+/**
+ * Ingest a batch of `[wvid, value]` tuples from the MT bridge. Writes each
+ * into the corresponding signal so any `effect` that read it re-runs on the
+ * sigx scheduler's next tick. Tuples for unregistered wvids (race with
+ * unmount) are silently dropped.
+ */
+export declare function ingestAvPublishes(updates: Array<[number, unknown]>): void;
+/** Reset hook — for testing. Drops every registered sink. */
+export declare function resetBgAvBridge(): void;
+/** Test hook — number of currently registered sinks. */
+export declare function bgAvSinkCount(): number;

package/dist/bg-bridge.d.ts

@@ -0,0 +1,29 @@
+/**
+ * BG-side listener for the MT→BG `Lynx.Sigx.PublishEvent` channel.
+ *
+ * The MT-side hybrid worklet (`lynx-runtime-main/src/hybrid-worklet.ts`) calls
+ * `lynx.getJSContext().dispatchEvent({ type: 'Lynx.Sigx.PublishEvent', data })`
+ * to fire the BG handler whose sign is captured in the hybrid ctx. We listen
+ * for that event here and route through the existing event-registry's
+ * `publishEvent` — the same dispatcher Lynx native calls when a normal
+ * `bindtap` fires on BG. The user's BG handler runs in the same call-stack
+ * shape it always has, so signal updates / `count.value++` etc. work without
+ * any awareness that the trigger came from MT.
+ *
+ * Side-effect import from `index.ts` so the listener is wired before any
+ * user code runs.
+ *
+ * CROSS-THREAD ASYMMETRY (per @lynx-js/react/runtime/lib/worklet/call/runOnBackground.js):
+ *   - MT → BG dispatch: MT calls `lynx.getJSContext().dispatchEvent(...)`,
+ *     BG listens via `lynx.getCoreContext().addEventListener(...)`.
+ *   - BG → MT dispatch: BG calls `lynx.getCoreContext().dispatchEvent(...)`,
+ *     MT listens via `lynx.getJSContext().addEventListener(...)`.
+ * Each side calls a DIFFERENT method to reach the other thread — they're not
+ * symmetric. Listening on `lynx.getJSContext()` from BG just listens on BG's
+ * own context (no cross-thread events arrive).
+ *
+ * `lynx` is closure-injected by RuntimeWrapperWebpackPlugin (declared in
+ * shims.d.ts). It is NOT available as `globalThis.lynx` — use the free
+ * identifier directly.
+ */
+export {};

package/dist/event-registry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Sign-based event handler registry for the Background Thread.
+ *
+ * When patchProp registers an event handler, it gets a unique sign string.
+ * The Main Thread stores this sign with __AddEvent().  When Native fires an
+ * event it calls publishEvent(sign, data) on the BG Thread, which looks up
+ * the handler and executes it directly — no cross-thread round-trip.
+ *
+ * sigx uses signal closures, so event handlers are plain functions captured by the component's
+ * render closure.
+ */
+/**
+ * Register a handler and return a unique sign string.
+ * The sign is passed to __AddEvent so that the MTS can route events back.
+ */
+export declare function register(handler: (data: unknown) => void): string;
+/**
+ * Update the handler for an existing sign without changing the sign.
+ * Used on re-renders: keeps the same sign registered on the Main Thread
+ * while pointing it to the freshest handler closure.
+ */
+export declare function updateHandler(sign: string, handler: (data: unknown) => void): void;
+/**
+ * Get the current handler for a sign.
+ */
+export declare function getHandler(sign: string): ((data: unknown) => void) | undefined;
+/**
+ * Unregister a handler by its sign.
+ */
+export declare function unregister(sign: string): void;
+/**
+ * Called by Lynx Native when an event fires on the BG Thread.
+ * Looks up the handler by sign and invokes it with the event data.
+ */
+export declare function publishEvent(sign: string, data: unknown): void;
+/** Reset all state — for testing only. */
+export declare function resetRegistry(): void;

package/dist/flush.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Flush scheduler — re-exports from op-queue.ts.
+ *
+ * In the new architecture, the BG thread no longer calls __FlushElementTree
+ * directly. Instead, ops are batched in a queue and flushed to the Main Thread
+ * via sigxPatchUpdate. This file exists for backwards-compatible imports.
+ */
+export { scheduleFlush, flushNow, resetOpQueue as resetFlushState } from './op-queue.js';

package/dist/hmr.d.ts

@@ -0,0 +1,35 @@
+/**
+ * HMR runtime for sigx-lynx (rspack/rsbuild).
+ *
+ * The `@sigx/lynx` meta package inlines runtime-core into a single bundle,
+ * so `@sigx/runtime-core/internals` would resolve to a *different* copy of
+ * the plugin registry than the one used by `component()`.  To work around
+ * this the HMR loader injects a call to `initHMR(registerComponentPlugin)`
+ * where `registerComponentPlugin` is imported from `@sigx/lynx` (the same
+ * bundle the app uses), ensuring a single shared plugin array.
+ *
+ * Flow:
+ *   1. Loader prepends:
+ *        import { __registerComponentPlugin } from '@sigx/lynx';
+ *        import { initHMR, registerHMRModule } from '@sigx/lynx-runtime/hmr';
+ *        initHMR(__registerComponentPlugin);
+ *        registerHMRModule('<moduleId>');
+ *   2. On first call, `initHMR` installs the onDefine plugin.
+ *   3. On HMR update the module re-executes, `registerHMRModule` resets
+ *      the per-module index, `component()` fires `onDefine`, and existing
+ *      instances are patched in-place (property-ops only — no crash).
+ */
+type RegisterFn = (plugin: {
+    onDefine?: (name: string | undefined, factory: any, setup: Function) => void;
+}) => void;
+/**
+ * Initialise the HMR plugin using the *app-side* registerComponentPlugin.
+ * Called once by the loader-injected preamble.  Idempotent.
+ */
+export declare function initHMR(registerComponentPlugin: RegisterFn): void;
+/**
+ * Register the current module for HMR tracking.
+ * Called at the top of each transformed module by the HMR loader.
+ */
+export declare function registerHMRModule(moduleId: string): void;
+export {};

package/dist/hmr.js

@@ -0,0 +1,38 @@
+//#region src/hmr.ts
+var e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), n = null, r = !1;
+function i(t) {
+	r || (r = !0, t({ onDefine(t, n, r) {
+		let i = o();
+		if (!i) return;
+		n.__hmrId = i;
+		let a = e.get(i);
+		a && a.size > 0 && a.forEach((e) => {
+			try {
+				let t = r(e.ctx);
+				e.ctx.renderFn = t, e.ctx.update();
+			} catch (e) {
+				console.error(`[sigx-hmr] Failed to update ${t || "component"}:`, e);
+			}
+		});
+		let s = r;
+		n.__setup = (t) => {
+			let n = s(t), r = { ctx: t }, a = e.get(i);
+			return a || (a = /* @__PURE__ */ new Set(), e.set(i, a)), a.add(r), t.onUnmounted(() => {
+				let t = e.get(i);
+				t && t.delete(r);
+			}), n;
+		};
+	} }));
+}
+function a(e) {
+	n = e, t.set(e, 0);
+}
+function o() {
+	if (!n) return null;
+	let e = t.get(n) || 0;
+	return t.set(n, e + 1), `${n}:${e}`;
+}
+//#endregion
+export { i as initHMR, a as registerHMRModule };
+
+//# sourceMappingURL=hmr.js.map

package/dist/hmr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.js","names":[],"sources":["../src/hmr.ts"],"sourcesContent":["/**\n * HMR runtime for sigx-lynx (rspack/rsbuild).\n *\n * The `@sigx/lynx` meta package inlines runtime-core into a single bundle,\n * so `@sigx/runtime-core/internals` would resolve to a *different* copy of\n * the plugin registry than the one used by `component()`.  To work around\n * this the HMR loader injects a call to `initHMR(registerComponentPlugin)`\n * where `registerComponentPlugin` is imported from `@sigx/lynx` (the same\n * bundle the app uses), ensuring a single shared plugin array.\n *\n * Flow:\n *   1. Loader prepends:\n *        import { __registerComponentPlugin } from '@sigx/lynx';\n *        import { initHMR, registerHMRModule } from '@sigx/lynx-runtime/hmr';\n *        initHMR(__registerComponentPlugin);\n *        registerHMRModule('<moduleId>');\n *   2. On first call, `initHMR` installs the onDefine plugin.\n *   3. On HMR update the module re-executes, `registerHMRModule` resets\n *      the per-module index, `component()` fires `onDefine`, and existing\n *      instances are patched in-place (property-ops only — no crash).\n */\n\n// Type-only import — NOT a runtime import from runtime-core\nimport type { ComponentSetupContext } from '@sigx/runtime-core/internals';\n\ntype RegisterFn = (plugin: { onDefine?: (name: string | undefined, factory: any, setup: Function) => void }) => void;\n\ninterface InstanceEntry {\n    ctx: ComponentSetupContext;\n}\n\n// Track instances by component ID (moduleId:index)\nconst instancesByComponentId = new Map<string, Set<InstanceEntry>>();\n\n// Track component definition order within each module\nconst moduleComponentIndex = new Map<string, number>();\n\n// Current module being registered\nlet currentModuleId: string | null = null;\n\nlet installed = false;\n\n/**\n * Initialise the HMR plugin using the *app-side* registerComponentPlugin.\n * Called once by the loader-injected preamble.  Idempotent.\n */\nexport function initHMR(registerComponentPlugin: RegisterFn): void {\n    if (installed) return;\n    installed = true;\n\n    registerComponentPlugin({\n        onDefine(name: string | undefined, factory: any, setup: Function) {\n            const componentId = getNextComponentId();\n            if (!componentId) return;\n\n            factory.__hmrId = componentId;\n\n            const existingInstances = instancesByComponentId.get(componentId);\n\n            if (existingInstances && existingInstances.size > 0) {\n                // HMR update: patch all existing instances with the new setup\n                existingInstances.forEach(instance => {\n                    try {\n                        const newRenderFn = setup(instance.ctx);\n                        instance.ctx.renderFn = newRenderFn;\n                        instance.ctx.update();\n                    } catch (e) {\n                        console.error(`[sigx-hmr] Failed to update ${name || 'component'}:`, e);\n                    }\n                });\n            }\n\n            // Wrap setup to track future instances\n            const originalSetup = setup;\n\n            factory.__setup = (ctx: ComponentSetupContext) => {\n                const renderFn = originalSetup(ctx);\n\n                const instance: InstanceEntry = { ctx };\n\n                let instances = instancesByComponentId.get(componentId);\n                if (!instances) {\n                    instances = new Set();\n                    instancesByComponentId.set(componentId, instances);\n                }\n                instances.add(instance);\n\n                ctx.onUnmounted(() => {\n                    const instances = instancesByComponentId.get(componentId);\n                    if (instances) instances.delete(instance);\n                });\n\n                return renderFn;\n            };\n        }\n    });\n}\n\n/**\n * Register the current module for HMR tracking.\n * Called at the top of each transformed module by the HMR loader.\n */\nexport function registerHMRModule(moduleId: string): void {\n    currentModuleId = moduleId;\n    moduleComponentIndex.set(moduleId, 0);\n}\n\n/**\n * Get the next component ID for the current module.\n */\nfunction getNextComponentId(): string | null {\n    if (!currentModuleId) return null;\n\n    const index = moduleComponentIndex.get(currentModuleId) || 0;\n    moduleComponentIndex.set(currentModuleId, index + 1);\n\n    return `${currentModuleId}:${index}`;\n}\n"],"mappings":";AAgCA,IAAM,oBAAyB,IAAI,KAAiC,EAG9D,oBAAuB,IAAI,KAAqB,EAGlD,IAAiC,MAEjC,IAAY;AAMhB,SAAgB,EAAQ,GAA2C;CAC3D,MACJ,IAAY,IAEZ,EAAwB,EACpB,SAAS,GAA0B,GAAc,GAAiB;EAC9D,IAAM,IAAc,GAAoB;EACxC,IAAI,CAAC,GAAa;EAElB,EAAQ,UAAU;EAElB,IAAM,IAAoB,EAAuB,IAAI,EAAY;EAEjE,AAAI,KAAqB,EAAkB,OAAO,KAE9C,EAAkB,SAAQ,MAAY;GAClC,IAAI;IACA,IAAM,IAAc,EAAM,EAAS,IAAI;IAEvC,AADA,EAAS,IAAI,WAAW,GACxB,EAAS,IAAI,QAAQ;YAChB,GAAG;IACR,QAAQ,MAAM,+BAA+B,KAAQ,YAAY,IAAI,EAAE;;IAE7E;EAIN,IAAM,IAAgB;EAEtB,EAAQ,WAAW,MAA+B;GAC9C,IAAM,IAAW,EAAc,EAAI,EAE7B,IAA0B,EAAE,QAAK,EAEnC,IAAY,EAAuB,IAAI,EAAY;GAYvD,OAXK,MACD,oBAAY,IAAI,KAAK,EACrB,EAAuB,IAAI,GAAa,EAAU,GAEtD,EAAU,IAAI,EAAS,EAEvB,EAAI,kBAAkB;IAClB,IAAM,IAAY,EAAuB,IAAI,EAAY;IACzD,AAAI,KAAW,EAAU,OAAO,EAAS;KAC3C,EAEK;;IAGlB,CAAC;;AAON,SAAgB,EAAkB,GAAwB;CAEtD,AADA,IAAkB,GAClB,EAAqB,IAAI,GAAU,EAAE;;AAMzC,SAAS,IAAoC;CACzC,IAAI,CAAC,GAAiB,OAAO;CAE7B,IAAM,IAAQ,EAAqB,IAAI,EAAgB,IAAI;CAG3D,OAFA,EAAqB,IAAI,GAAiB,IAAQ,EAAE,EAE7C,GAAG,EAAgB,GAAG"}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import './jsx.js';
+import './types.js';
+import './model-processor.js';
+import './bg-bridge.js';
+import './run-on-background.js';
+export { render, lynxMount } from './render.js';
+export { nodeOps } from './nodeOps.js';
+export type { LynxNode, LynxElement } from './nodeOps.js';
+export { ShadowElement, createPageRoot, resetShadowState } from './shadow-element.js';
+export { pushOp, takeOps, scheduleFlush, flushNow, resetOpQueue } from './op-queue.js';
+export { OP } from '@sigx/lynx-runtime-internal';
+export type { OpCode, MapperParams, RangeParams, BuiltinMapperName, AnimatedStyleMapper, } from '@sigx/lynx-runtime-internal';
+export { register, updateHandler, unregister, getHandler, publishEvent, resetRegistry, } from './event-registry.js';
+export { MainThreadRef, useMainThreadRef, resetWvidCounter, } from './main-thread-ref.js';
+export { registerBgSink, unregisterBgSink, ingestAvPublishes, resetBgAvBridge, bgAvSinkCount, } from './animated-bridge.js';
+export { useSharedValue, SharedValue, } from './animated/shared-value.js';
+export type { SharedValueState } from './animated/shared-value.js';
+export { useAnimatedStyle, resetAnimatedStyleBindingIds, } from './animated/use-animated-style.js';
+export { useAnimatedValue, AnimatedValue, } from './animated/animated-value.js';
+export type { AnimatedValueState } from './animated/animated-value.js';
+export { runOnMainThread, runOnBackground, resetThreading, transformToWorklet, resetRunOnBackgroundState, } from './threading.js';
+export { Gesture, GestureType, useGestureDetector, resetGestureIdCounter, } from './native/index.js';
+export type { GestureTypeValue, GestureWorklet, GestureCallback, BaseGesture, ComposedGesture, AnyGesture, } from './native/index.js';
+export type { LynxEventHandler, LynxCommonAttributes, ViewAttributes, TextAttributes, ImageAttributes, ScrollViewAttributes, ListAttributes, ListItemAttributes, InputAttributes, TextAreaAttributes, PageAttributes, SvgAttributes, FilterImageAttributes, MainThread, } from './jsx.js';