@rrjs/react-compat 0.1.0

package/README.md

@@ -0,0 +1,130 @@
+# @rrjs/react-compat
+
+React hooks implemented on top of signals. Designed so React code translates with minimal changes: state is read through a getter (`count()` instead of `count`). Inside JSX the Babel plugin handles this automatically.
+
+## Install
+
+```bash
+npm install @rrjs/react-compat @rrjs/signals @rrjs/renderer
+```
+
+## Quick start
+
+```js
+import { useState, useEffect, useMemo } from '@rrjs/react-compat'
+import { h, mount } from '@rrjs/renderer'
+
+function Counter() {
+  const [count, setCount] = useState(0)
+  const doubled = useMemo(() => count() * 2, [count])
+
+  useEffect(() => {
+    document.title = `Count: ${count()}`
+  }, [count])
+
+  return h('div', null,
+    h('p', null, () => `${count()} → ${doubled()}`),
+    h('button', { onClick: () => setCount(count() + 1) }, 'inc')
+  )
+}
+
+mount(Counter, document.getElementById('app'))
+```
+
+## Supported hooks
+
+| Hook | Status | Notes |
+|---|---|---|
+| `useState` | ✓ | Returns `[getter, setter]`. Functional updaters supported. |
+| `useReducer` | ✓ | Returns `[stateGetter, dispatch]`. Lazy init supported. |
+| `useMemo` | ✓ | Returns a getter. Wrapped in `computed` — auto-tracks signals read inside. |
+| `useCallback` | ✓ | Standard React behavior with dep array. |
+| `useEffect` | ✓ | Fires post-paint via `MessageChannel`. Cleanup runs before next effect. |
+| `useLayoutEffect` | ✓ | Fires synchronously before paint. |
+| `useRef` | ✓ | Plain mutable box. |
+| `useContext` | ✓ | Stack-based propagation. `createContext` + `Provider`. |
+| `useId` | ✓ | Generates `:rN:`-style ids. Client-only. |
+| `useImperativeHandle` | ✓ | Pairs with `forwardRef`. |
+| `useSyncExternalStore` | ✓ | Subscribes to external stores (Redux, Zustand, etc.). |
+| `useDeferredValue` | — | No-op; returns input as-is. |
+| `useTransition` | — | No-op; runs synchronously. |
+
+## Forwarding refs
+
+```js
+import { forwardRef, useRef } from '@rrjs/react-compat'
+
+const FancyInput = forwardRef((props, ref) =>
+  h('input', { ref, type: 'text', ...props })
+)
+
+function Form() {
+  const inputRef = useRef(null)
+  return h(FancyInput, { ref: inputRef })
+}
+```
+
+## Context
+
+```js
+import { createContext, useContext } from '@rrjs/react-compat'
+
+const ThemeContext = createContext('light')
+
+function App() {
+  return h(ThemeContext.Provider, { value: 'dark' },
+    h(ThemedButton, null)
+  )
+}
+
+function ThemedButton() {
+  const theme = useContext(ThemeContext)
+  return h('button', { className: theme }, 'click')
+}
+```
+
+Nested providers are supported. Each `Provider` push is paired with a pop after children mount.
+
+## External stores (Redux, Zustand, etc.)
+
+```js
+import { useSyncExternalStore } from '@rrjs/react-compat'
+
+function Counter({ store }) {
+  const state = useSyncExternalStore(store.subscribe, store.getState)
+  return h('div', null, () => state().count)
+}
+```
+
+Same contract as React 18+. Any state library that ships React bindings using `useSyncExternalStore` should work.
+
+## Why getters instead of values
+
+In React, `const [count, setCount] = useState(0)` makes `count` a plain number. That works because React re-runs the entire component function on every state change — the new value of `count` comes from the new render.
+
+In a signal model, the component runs once. After that, `count` would be frozen at the initial value forever. To stay reactive without re-running the component, `count` must be a function that reads the live signal. So `count` is a getter: `count()`.
+
+Inside JSX, the Babel plugin wraps `{count}` as `() => count`, and the renderer auto-invokes nested getters. So in JSX you write `{count}` the same as in React. Outside JSX (event handlers, useMemo factories, useEffect bodies), you call the getter: `count()`.
+
+## License
+MIT License
+
+Copyright (c) 2026 Saman Abaasi
+
+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/dist/context.d.ts

@@ -0,0 +1,14 @@
+export interface Context<T> {
+    _id: symbol;
+    _defaultValue: T;
+    Provider: (props: {
+        value: T;
+        children: any;
+    }) => any;
+}
+export declare function createContext<T>(defaultValue: T): Context<T>;
+export declare function pushContext(id: symbol, value: unknown): void;
+export declare function popContext(id: symbol): void;
+export declare function readContext<T>(context: Context<T>): T;
+export declare function withProvider<T, R>(context: Context<T>, value: T, fn: () => R): R;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,aAAa,EAAE,CAAC,CAAA;IAChB,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAA;KAAE,KAAK,GAAG,CAAA;CACtD;AAKD,wBAAgB,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgB5D;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAO5D;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAK3C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAMrD;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAOH"}

package/dist/context.js

@@ -0,0 +1,58 @@
+// ─── Context — Stack-Based Propagation ──────────────────────────────────────
+// Without a VDOM tree to walk, we use mount-time scoping:
+//   - When a Provider mounts its children, it pushes its value onto the stack.
+//   - useContext reads the current top of the stack for that context.
+//   - When children finish mounting, the Provider pops its value.
+//
+// This works because mounting is synchronous and depth-first — the same property
+// React relies on for hook positional ordering.
+// One stack per context, keyed by the unique _id symbol
+const contextStacks = new Map();
+export function createContext(defaultValue) {
+    const id = Symbol('Context');
+    const Provider = (props) => {
+        pushContext(id, props.value);
+        // The renderer will call this and use the returned children.
+        // It's responsible for popping after the children finish mounting —
+        // we handle that via withProvider() below.
+        return props.children;
+    };
+    return {
+        _id: id,
+        _defaultValue: defaultValue,
+        Provider,
+    };
+}
+export function pushContext(id, value) {
+    let stack = contextStacks.get(id);
+    if (!stack) {
+        stack = [];
+        contextStacks.set(id, stack);
+    }
+    stack.push(value);
+}
+export function popContext(id) {
+    const stack = contextStacks.get(id);
+    if (stack && stack.length > 0) {
+        stack.pop();
+    }
+}
+export function readContext(context) {
+    const stack = contextStacks.get(context._id);
+    if (stack && stack.length > 0) {
+        return stack[stack.length - 1];
+    }
+    return context._defaultValue;
+}
+// Used by tests and the renderer to wrap a function call with a Provider's value.
+// Pushes value before fn runs, pops after — even if fn throws.
+export function withProvider(context, value, fn) {
+    pushContext(context._id, value);
+    try {
+        return fn();
+    }
+    finally {
+        popContext(context._id);
+    }
+}
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,0DAA0D;AAC1D,+EAA+E;AAC/E,sEAAsE;AACtE,kEAAkE;AAClE,EAAE;AACF,iFAAiF;AACjF,gDAAgD;AAQhD,wDAAwD;AACxD,MAAM,aAAa,GAAG,IAAI,GAAG,EAAqB,CAAA;AAElD,MAAM,UAAU,aAAa,CAAI,YAAe;IAC9C,MAAM,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC,CAAA;IAE5B,MAAM,QAAQ,GAAG,CAAC,KAAkC,EAAE,EAAE;QACtD,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;QAC5B,6DAA6D;QAC7D,oEAAoE;QACpE,2CAA2C;QAC3C,OAAO,KAAK,CAAC,QAAQ,CAAA;IACvB,CAAC,CAAA;IAED,OAAO;QACL,GAAG,EAAE,EAAE;QACP,aAAa,EAAE,YAAY;QAC3B,QAAQ;KACT,CAAA;AACH,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,EAAU,EAAE,KAAc;IACpD,IAAI,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACjC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,EAAE,CAAA;QACV,aAAa,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAA;IAC9B,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACnB,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,EAAU;IACnC,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACnC,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9B,KAAK,CAAC,GAAG,EAAE,CAAA;IACb,CAAC;AACH,CAAC;AAED,MAAM,UAAU,WAAW,CAAI,OAAmB;IAChD,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IAC5C,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAM,CAAA;IACrC,CAAC;IACD,OAAO,OAAO,CAAC,aAAa,CAAA;AAC9B,CAAC;AAED,kFAAkF;AAClF,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAC1B,OAAmB,EACnB,KAAQ,EACR,EAAW;IAEX,WAAW,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAC/B,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,CAAA;IACb,CAAC;YAAS,CAAC;QACT,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IACzB,CAAC;AACH,CAAC"}

package/dist/forwardRef.d.ts

@@ -0,0 +1,13 @@
+import type { RefObject } from './hooks/useRef';
+export type Ref<T> = ((instance: T | null) => void) | RefObject<T> | null;
+export declare const FORWARD_REF: unique symbol;
+export interface ForwardRefComponent<P, T> {
+    (props: P & {
+        ref?: Ref<T>;
+    }): any;
+    [FORWARD_REF]: true;
+    _render: (props: P, ref: Ref<T>) => any;
+}
+export declare function forwardRef<P, T>(render: (props: P, ref: Ref<T>) => any): ForwardRefComponent<P, T>;
+export declare function isForwardRef(value: unknown): value is ForwardRefComponent<any, any>;
+//# sourceMappingURL=forwardRef.d.ts.map

package/dist/forwardRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardRef.d.ts","sourceRoot":"","sources":["../src/forwardRef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG/C,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;AAIzE,eAAO,MAAM,WAAW,eAAuB,CAAA;AAE/C,MAAM,WAAW,mBAAmB,CAAC,CAAC,EAAE,CAAC;IACvC,CAAC,KAAK,EAAE,CAAC,GAAG;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;KAAE,GAAG,GAAG,CAAA;IAClC,CAAC,WAAW,CAAC,EAAE,IAAI,CAAA;IACnB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAA;CACxC;AAOD,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,GACrC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAY3B;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAAC,GAAG,EAAE,GAAG,CAAC,CAKnF"}

package/dist/forwardRef.js

@@ -0,0 +1,24 @@
+// The marker that lets the renderer know this is a forwardRef wrapper.
+// We use a Symbol so it's unambiguous and cannot collide with user code.
+export const FORWARD_REF = Symbol('forwardRef');
+// forwardRef wraps a function component that accepts (props, ref) and returns
+// a callable component that the renderer recognizes. When the renderer sees
+// the FORWARD_REF marker, it extracts the ref prop and passes it as the second
+// argument to the user's render function.
+export function forwardRef(render) {
+    const component = ((props) => {
+        // Direct invocation path — extract ref, call user render.
+        // The renderer will normally take the FORWARD_REF path instead and
+        // call _render directly. This branch is for completeness.
+        const { ref, ...rest } = props;
+        return render(rest, ref ?? null);
+    });
+    component[FORWARD_REF] = true;
+    component._render = render;
+    return component;
+}
+export function isForwardRef(value) {
+    return (typeof value === 'function' &&
+        value[FORWARD_REF] === true);
+}
+//# sourceMappingURL=forwardRef.js.map

package/dist/forwardRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardRef.js","sourceRoot":"","sources":["../src/forwardRef.ts"],"names":[],"mappings":"AAKA,uEAAuE;AACvE,yEAAyE;AACzE,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC,CAAA;AAQ/C,8EAA8E;AAC9E,4EAA4E;AAC5E,+EAA+E;AAC/E,0CAA0C;AAE1C,MAAM,UAAU,UAAU,CACxB,MAAsC;IAEtC,MAAM,SAAS,GAAG,CAAC,CAAC,KAA2B,EAAE,EAAE;QACjD,0DAA0D;QAC1D,mEAAmE;QACnE,0DAA0D;QAC1D,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,KAAY,CAAA;QACrC,OAAO,MAAM,CAAC,IAAS,EAAE,GAAG,IAAI,IAAI,CAAC,CAAA;IACvC,CAAC,CAA8B,CAAA;IAE/B,SAAS,CAAC,WAAW,CAAC,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,OAAO,GAAG,MAAM,CAAA;IAC1B,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,CACL,OAAO,KAAK,KAAK,UAAU;QAC1B,KAAa,CAAC,WAAW,CAAC,KAAK,IAAI,CACrC,CAAA;AACH,CAAC"}

package/dist/hooks/noop-hooks.d.ts

@@ -0,0 +1,9 @@
+type StartTransition = (fn: () => void) => void;
+export declare function useTransition(): [() => boolean, StartTransition];
+export declare function useDeferredValue<T>(value: T): T;
+type EffectCleanup = void | (() => void);
+type EffectFn = () => EffectCleanup;
+export declare function useInsertionEffect(fn: EffectFn, deps?: ReadonlyArray<unknown>): void;
+export declare function useDebugValue<T>(_value: T, _formatter?: (v: T) => any): void;
+export {};
+//# sourceMappingURL=noop-hooks.d.ts.map

package/dist/hooks/noop-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-hooks.d.ts","sourceRoot":"","sources":["../../src/hooks/noop-hooks.ts"],"names":[],"mappings":"AAeA,KAAK,eAAe,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;AAE/C,wBAAgB,aAAa,IAAI,CAAC,MAAM,OAAO,EAAE,eAAe,CAAC,CAMhE;AAWD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAE/C;AA6BD,KAAK,aAAa,GAAG,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAA;AACxC,KAAK,QAAQ,GAAG,MAAM,aAAa,CAAA;AAEnC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,IAAI,CAyBpF;AAOD,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,GAAG,IAAI,CAE5E"}

package/dist/hooks/noop-hooks.js

@@ -0,0 +1,60 @@
+import { getCurrentInstance } from '../instance';
+export function useTransition() {
+    const isPending = () => false;
+    const startTransition = (fn) => {
+        fn();
+    };
+    return [isPending, startTransition];
+}
+// ─── useDeferredValue ────────────────────────────────────────────────────────
+// In React, useDeferredValue returns a "stale" version of a value that updates
+// only when the renderer has spare time. Used for typeahead inputs and similar
+// patterns where intermediate values can be skipped.
+//
+// Without concurrent rendering, deferral has no meaning. We return the input
+// value unchanged. Apps using useDeferredValue still work — they just get the
+// fresh value immediately. No deferral, no batching of intermediate updates.
+export function useDeferredValue(value) {
+    return value;
+}
+function depsChanged(next, prev) {
+    if (next === undefined || prev === undefined)
+        return true;
+    if (next.length !== prev.length)
+        return true;
+    for (let i = 0; i < next.length; i++) {
+        if (!Object.is(next[i], prev[i]))
+            return true;
+    }
+    return false;
+}
+export function useInsertionEffect(fn, deps) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    const existing = instance.hooks[i];
+    const makeEntry = (hook) => ({
+        cleanup: hook.cleanup,
+        run: () => {
+            const result = fn();
+            hook.cleanup = typeof result === 'function' ? result : null;
+        },
+    });
+    if (existing === undefined) {
+        const hook = { deps, cleanup: null };
+        instance.hooks[i] = hook;
+        instance.layoutEffects.push(makeEntry(hook));
+        return;
+    }
+    if (depsChanged(deps, existing.deps)) {
+        existing.deps = deps;
+        instance.layoutEffects.push(makeEntry(existing));
+    }
+}
+// ─── useDebugValue ───────────────────────────────────────────────────────────
+// useDebugValue annotates custom hooks for React DevTools. It has no runtime
+// behavior — purely a hint to the devtools layer about what to display.
+// We have no DevTools integration. The hook is a true no-op.
+export function useDebugValue(_value, _formatter) {
+    // Intentionally empty
+}
+//# sourceMappingURL=noop-hooks.js.map

package/dist/hooks/noop-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-hooks.js","sourceRoot":"","sources":["../../src/hooks/noop-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAe,MAAM,aAAa,CAAA;AAiB7D,MAAM,UAAU,aAAa;IAC3B,MAAM,SAAS,GAAG,GAAG,EAAE,CAAC,KAAK,CAAA;IAC7B,MAAM,eAAe,GAAoB,CAAC,EAAE,EAAE,EAAE;QAC9C,EAAE,EAAE,CAAA;IACN,CAAC,CAAA;IACD,OAAO,CAAC,SAAS,EAAE,eAAe,CAAC,CAAA;AACrC,CAAC;AAED,gFAAgF;AAChF,+EAA+E;AAC/E,+EAA+E;AAC/E,qDAAqD;AACrD,EAAE;AACF,6EAA6E;AAC7E,8EAA8E;AAC9E,6EAA6E;AAE7E,MAAM,UAAU,gBAAgB,CAAI,KAAQ;IAC1C,OAAO,KAAK,CAAA;AACd,CAAC;AAiBD,SAAS,WAAW,CAClB,IAAwC,EACxC,IAAwC;IAExC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IACzD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;IAC/C,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAKD,MAAM,UAAU,kBAAkB,CAAC,EAAY,EAAE,IAA6B;IAC5E,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAuC,CAAA;IAExE,MAAM,SAAS,GAAG,CAAC,IAA4B,EAAe,EAAE,CAAC,CAAC;QAChE,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,GAAG,EAAE,GAAG,EAAE;YACR,MAAM,MAAM,GAAG,EAAE,EAAE,CAAA;YACnB,IAAI,CAAC,OAAO,GAAG,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7D,CAAC;KACF,CAAC,CAAA;IAEF,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,GAA2B,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;QAC5D,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;QACxB,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAA;QAC5C,OAAM;IACR,CAAC;IAED,IAAI,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAA;IAClD,CAAC;AACH,CAAC;AAED,gFAAgF;AAChF,6EAA6E;AAC7E,wEAAwE;AACxE,6DAA6D;AAE7D,MAAM,UAAU,aAAa,CAAI,MAAS,EAAE,UAA0B;IACpE,sBAAsB;AACxB,CAAC"}

package/dist/hooks/useCallback.d.ts

@@ -0,0 +1,2 @@
+export declare function useCallback<T extends (...args: any[]) => any>(fn: T, deps?: ReadonlyArray<unknown>): T;
+//# sourceMappingURL=useCallback.d.ts.map

package/dist/hooks/useCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCallback.d.ts","sourceRoot":"","sources":["../../src/hooks/useCallback.ts"],"names":[],"mappings":"AA2BA,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC3D,EAAE,EAAE,CAAC,EACL,IAAI,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAC5B,CAAC,CAiBH"}

package/dist/hooks/useCallback.js

@@ -0,0 +1,34 @@
+import { getCurrentInstance } from '../instance';
+function depsChanged(next, prev) {
+    if (next === undefined || prev === undefined)
+        return true;
+    if (next.length !== prev.length)
+        return true;
+    for (let i = 0; i < next.length; i++) {
+        if (!Object.is(next[i], prev[i]))
+            return true;
+    }
+    return false;
+}
+// useCallback caches a function reference between renders.
+// Same dep-array semantics as useMemo, but the cached value IS the function
+// rather than the result of calling it.
+//
+// In a snapshot-based hook model (which ours is, for React compatibility),
+// useCallback is what prevents stale references when passing handlers down
+// to memoized children — same role it plays in React.
+export function useCallback(fn, deps) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    const existing = instance.hooks[i];
+    if (existing === undefined) {
+        instance.hooks[i] = { fn, deps };
+        return fn;
+    }
+    if (depsChanged(deps, existing.deps)) {
+        existing.fn = fn;
+        existing.deps = deps;
+    }
+    return existing.fn;
+}
+//# sourceMappingURL=useCallback.js.map

package/dist/hooks/useCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCallback.js","sourceRoot":"","sources":["../../src/hooks/useCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAOhD,SAAS,WAAW,CAClB,IAAwC,EACxC,IAAwC;IAExC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IACzD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;IAC/C,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,2DAA2D;AAC3D,4EAA4E;AAC5E,wCAAwC;AACxC,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,sDAAsD;AAEtD,MAAM,UAAU,WAAW,CACzB,EAAK,EACL,IAA6B;IAE7B,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAmC,CAAA;IAEpE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,EAAwB,CAAA;QACtD,OAAO,EAAE,CAAA;IACX,CAAC;IAED,IAAI,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAA;QAChB,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;IACtB,CAAC;IAED,OAAO,QAAQ,CAAC,EAAE,CAAA;AACpB,CAAC"}

package/dist/hooks/useContext.d.ts

@@ -0,0 +1,3 @@
+import { Context } from '../context';
+export declare function useContext<T>(context: Context<T>): T;
+//# sourceMappingURL=useContext.d.ts.map

package/dist/hooks/useContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContext.d.ts","sourceRoot":"","sources":["../../src/hooks/useContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,OAAO,EAAE,MAAM,YAAY,CAAA;AAYjD,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAEpD"}

package/dist/hooks/useContext.js

@@ -0,0 +1,14 @@
+import { readContext } from '../context';
+// useContext does NOT need a hook slot.
+// It just reads the current value from the global stack for this context.
+// No state to persist between renders — the stack handles it.
+//
+// Note: this means useContext is the only React-shim hook that doesn't
+// allocate a hookIndex slot. We deliberately do NOT call instance.hookIndex++
+// because we want the hook to be callable conditionally without breaking
+// positional ordering for other hooks. React works the same way: useContext
+// doesn't store anything on the Fiber.
+export function useContext(context) {
+    return readContext(context);
+}
+//# sourceMappingURL=useContext.js.map

package/dist/hooks/useContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContext.js","sourceRoot":"","sources":["../../src/hooks/useContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAW,MAAM,YAAY,CAAA;AAEjD,wCAAwC;AACxC,0EAA0E;AAC1E,8DAA8D;AAC9D,EAAE;AACF,uEAAuE;AACvE,8EAA8E;AAC9E,yEAAyE;AACzE,4EAA4E;AAC5E,uCAAuC;AAEvC,MAAM,UAAU,UAAU,CAAI,OAAmB;IAC/C,OAAO,WAAW,CAAC,OAAO,CAAC,CAAA;AAC7B,CAAC"}

package/dist/hooks/useEffect.d.ts

@@ -0,0 +1,5 @@
+type EffectCleanup = void | (() => void);
+type EffectFn = () => EffectCleanup;
+export declare function useEffect(fn: EffectFn, deps?: ReadonlyArray<unknown>): void;
+export {};
+//# sourceMappingURL=useEffect.d.ts.map

package/dist/hooks/useEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffect.d.ts","sourceRoot":"","sources":["../../src/hooks/useEffect.ts"],"names":[],"mappings":"AA2BA,KAAK,aAAa,GAAG,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAA;AACxC,KAAK,QAAQ,GAAG,MAAM,aAAa,CAAA;AAEnC,wBAAgB,SAAS,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,IAAI,CAkB3E"}

package/dist/hooks/useEffect.js

@@ -0,0 +1,38 @@
+import { getCurrentInstance } from '../instance';
+function depsChanged(next, prev) {
+    if (next === undefined || prev === undefined)
+        return true;
+    if (next.length !== prev.length)
+        return true;
+    for (let i = 0; i < next.length; i++) {
+        if (!Object.is(next[i], prev[i]))
+            return true;
+    }
+    return false;
+}
+export function useEffect(fn, deps) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    const existing = instance.hooks[i];
+    if (existing === undefined) {
+        // First render — always schedule. There are no prev deps to compare to.
+        instance.hooks[i] = { deps, cleanup: null };
+        instance.passiveEffects.push(makeEntry(instance.hooks[i], fn));
+        return;
+    }
+    // Subsequent render — only re-run if deps changed (or no deps given).
+    if (depsChanged(deps, existing.deps)) {
+        existing.deps = deps;
+        instance.passiveEffects.push(makeEntry(existing, fn));
+    }
+}
+function makeEntry(hook, fn) {
+    return {
+        cleanup: hook.cleanup,
+        run: () => {
+            const result = fn();
+            hook.cleanup = typeof result === 'function' ? result : null;
+        },
+    };
+}
+//# sourceMappingURL=useEffect.js.map

package/dist/hooks/useEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffect.js","sourceRoot":"","sources":["../../src/hooks/useEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAe,MAAM,aAAa,CAAA;AAO7D,SAAS,WAAW,CAClB,IAAwC,EACxC,IAAwC;IAExC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IACzD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;IAC/C,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAaD,MAAM,UAAU,SAAS,CAAC,EAAY,EAAE,IAA6B;IACnE,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAA8B,CAAA;IAE/D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,wEAAwE;QACxE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAmB,CAAA;QAC5D,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAkB,EAAE,EAAE,CAAC,CAAC,CAAA;QAC/E,OAAM;IACR,CAAC;IAED,sEAAsE;IACtE,IAAI,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAA;IACvD,CAAC;AACH,CAAC;AAED,SAAS,SAAS,CAAC,IAAmB,EAAE,EAAY;IAClD,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,GAAG,EAAE,GAAG,EAAE;YACR,MAAM,MAAM,GAAG,EAAE,EAAE,CAAA;YACnB,IAAI,CAAC,OAAO,GAAG,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7D,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/hooks/useId.d.ts

@@ -0,0 +1,3 @@
+export declare function useId(): string;
+export declare function _resetIdCounter(): void;
+//# sourceMappingURL=useId.d.ts.map

package/dist/hooks/useId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.d.ts","sourceRoot":"","sources":["../../src/hooks/useId.ts"],"names":[],"mappings":"AAwBA,wBAAgB,KAAK,IAAI,MAAM,CAS9B;AAGD,wBAAgB,eAAe,IAAI,IAAI,CAEtC"}

package/dist/hooks/useId.js

@@ -0,0 +1,28 @@
+import { getCurrentInstance } from '../instance';
+// A global counter is the simplest correct implementation client-side.
+// React 18 also uses a counter, though theirs encodes tree position
+// for SSR/hydration matching. For pure client rendering, a counter is fine.
+//
+// React's id format is ":r0:", ":r1:", etc. We match the format so that
+// any third-party library checking the format works the same way.
+let nextId = 0;
+function generateId() {
+    return `:r${(nextId++).toString(36)}:`;
+}
+// useId returns a stable unique string for each call site in each component.
+// On the first render of a component, generate a fresh id.
+// On any subsequent render of the same component instance, return the cached id.
+// This is what makes <label htmlFor={id}> match <input id={id} /> across renders.
+export function useId() {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    if (instance.hooks[i] === undefined) {
+        instance.hooks[i] = { id: generateId() };
+    }
+    return instance.hooks[i].id;
+}
+// Exposed for testing — lets tests reset the counter for predictable assertions
+export function _resetIdCounter() {
+    nextId = 0;
+}
+//# sourceMappingURL=useId.js.map

package/dist/hooks/useId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.js","sourceRoot":"","sources":["../../src/hooks/useId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAMhD,uEAAuE;AACvE,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,wEAAwE;AACxE,kEAAkE;AAElE,IAAI,MAAM,GAAG,CAAC,CAAA;AAEd,SAAS,UAAU;IACjB,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAA;AACxC,CAAC;AAED,6EAA6E;AAC7E,2DAA2D;AAC3D,iFAAiF;AACjF,kFAAkF;AAElF,MAAM,UAAU,KAAK;IACnB,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACpC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,UAAU,EAAE,EAAe,CAAA;IACvD,CAAC;IAED,OAAQ,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAe,CAAC,EAAE,CAAA;AAC5C,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,eAAe;IAC7B,MAAM,GAAG,CAAC,CAAA;AACZ,CAAC"}

package/dist/hooks/useImperativeHandle.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from '../forwardRef';
+export declare function useImperativeHandle<T>(ref: Ref<T> | undefined, factory: () => T, deps?: ReadonlyArray<unknown>): void;
+//# sourceMappingURL=useImperativeHandle.d.ts.map

package/dist/hooks/useImperativeHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeHandle.d.ts","sourceRoot":"","sources":["../../src/hooks/useImperativeHandle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAA;AA2BxC,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,EACvB,OAAO,EAAE,MAAM,CAAC,EAChB,IAAI,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAC5B,IAAI,CAmCN"}

package/dist/hooks/useImperativeHandle.js

@@ -0,0 +1,52 @@
+import { getCurrentInstance } from '../instance';
+function depsChanged(next, prev) {
+    if (next === undefined || prev === undefined)
+        return true;
+    if (next.length !== prev.length)
+        return true;
+    for (let i = 0; i < next.length; i++) {
+        if (!Object.is(next[i], prev[i]))
+            return true;
+    }
+    return false;
+}
+// useImperativeHandle customizes what a forwardRef ref exposes.
+// Instead of attaching the raw DOM node, the parent gets a custom handle
+// returned by the factory function.
+//
+// Timing: runs as a LAYOUT effect, before paint. This matches React's behavior —
+// the parent's ref must be populated before any rendered output is visible,
+// because useLayoutEffect in the PARENT might read from this ref immediately.
+export function useImperativeHandle(ref, factory, deps) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    const existing = instance.hooks[i];
+    const attach = {
+        cleanup: existing?.cleanup ?? null,
+        run: () => {
+            if (!ref)
+                return;
+            const value = factory();
+            if (typeof ref === 'function') {
+                ref(value);
+                instance.hooks[i].cleanup = () => ref(null);
+            }
+            else if (typeof ref === 'object' && 'current' in ref) {
+                ref.current = value;
+                instance.hooks[i].cleanup = () => {
+                    ref.current = null;
+                };
+            }
+        },
+    };
+    if (existing === undefined) {
+        instance.hooks[i] = { deps, cleanup: null };
+        instance.layoutEffects.push(attach);
+        return;
+    }
+    if (depsChanged(deps, existing.deps)) {
+        existing.deps = deps;
+        instance.layoutEffects.push(attach);
+    }
+}
+//# sourceMappingURL=useImperativeHandle.js.map

package/dist/hooks/useImperativeHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeHandle.js","sourceRoot":"","sources":["../../src/hooks/useImperativeHandle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAe,MAAM,aAAa,CAAA;AAQ7D,SAAS,WAAW,CAClB,IAAwC,EACxC,IAAwC;IAExC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IACzD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;IAC/C,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,gEAAgE;AAChE,yEAAyE;AACzE,oCAAoC;AACpC,EAAE;AACF,iFAAiF;AACjF,4EAA4E;AAC5E,8EAA8E;AAE9E,MAAM,UAAU,mBAAmB,CACjC,GAAuB,EACvB,OAAgB,EAChB,IAA6B;IAE7B,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAwC,CAAA;IAEzE,MAAM,MAAM,GAAgB;QAC1B,OAAO,EAAE,QAAQ,EAAE,OAAO,IAAI,IAAI;QAClC,GAAG,EAAE,GAAG,EAAE;YACR,IAAI,CAAC,GAAG;gBAAE,OAAM;YAChB,MAAM,KAAK,GAAG,OAAO,EAAE,CAAA;YAEvB,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;gBAC9B,GAAG,CAAC,KAAK,CAAC,CAET;gBAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAA6B,CAAC,OAAO,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAC3E,CAAC;iBAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,SAAS,IAAI,GAAG,EAAE,CAAC;gBACvD,GAAG,CAAC,OAAO,GAAG,KAAK,CAClB;gBAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAA6B,CAAC,OAAO,GAAG,GAAG,EAAE;oBAC7D,GAAG,CAAC,OAAO,GAAG,IAAW,CAAA;gBAC3B,CAAC,CAAA;YACH,CAAC;QACH,CAAC;KACF,CAAA;IAED,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAA6B,CAAA;QACtE,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACnC,OAAM;IACR,CAAC;IAED,IAAI,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IACrC,CAAC;AACH,CAAC"}

package/dist/hooks/useLayoutEffect.d.ts

@@ -0,0 +1,5 @@
+type EffectCleanup = void | (() => void);
+type EffectFn = () => EffectCleanup;
+export declare function useLayoutEffect(fn: EffectFn, deps?: ReadonlyArray<unknown>): void;
+export {};
+//# sourceMappingURL=useLayoutEffect.d.ts.map

package/dist/hooks/useLayoutEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLayoutEffect.d.ts","sourceRoot":"","sources":["../../src/hooks/useLayoutEffect.ts"],"names":[],"mappings":"AAmBA,KAAK,aAAa,GAAG,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAA;AACxC,KAAK,QAAQ,GAAG,MAAM,aAAa,CAAA;AAUnC,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,IAAI,CAgBjF"}

package/dist/hooks/useLayoutEffect.js

@@ -0,0 +1,43 @@
+import { getCurrentInstance } from '../instance';
+function depsChanged(next, prev) {
+    if (next === undefined || prev === undefined)
+        return true;
+    if (next.length !== prev.length)
+        return true;
+    for (let i = 0; i < next.length; i++) {
+        if (!Object.is(next[i], prev[i]))
+            return true;
+    }
+    return false;
+}
+// useLayoutEffect runs SYNCHRONOUSLY during the commit phase, BEFORE paint.
+// This is the right hook for:
+//   - DOM measurement that affects layout (avoiding flicker)
+//   - Synchronous DOM mutations the user should not see partially applied
+//   - State updates that must complete before the user sees the screen
+//
+// The cost: it blocks paint. Use useEffect unless you have a specific reason.
+export function useLayoutEffect(fn, deps) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    const existing = instance.hooks[i];
+    if (existing === undefined) {
+        instance.hooks[i] = { deps, cleanup: null };
+        instance.layoutEffects.push(makeEntry(instance.hooks[i], fn));
+        return;
+    }
+    if (depsChanged(deps, existing.deps)) {
+        existing.deps = deps;
+        instance.layoutEffects.push(makeEntry(existing, fn));
+    }
+}
+function makeEntry(hook, fn) {
+    return {
+        cleanup: hook.cleanup,
+        run: () => {
+            const result = fn();
+            hook.cleanup = typeof result === 'function' ? result : null;
+        },
+    };
+}
+//# sourceMappingURL=useLayoutEffect.js.map

package/dist/hooks/useLayoutEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLayoutEffect.js","sourceRoot":"","sources":["../../src/hooks/useLayoutEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAe,MAAM,aAAa,CAAA;AAO7D,SAAS,WAAW,CAClB,IAAwC,EACxC,IAAwC;IAExC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IACzD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;IAC/C,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAKD,4EAA4E;AAC5E,8BAA8B;AAC9B,6DAA6D;AAC7D,0EAA0E;AAC1E,uEAAuE;AACvE,EAAE;AACF,8EAA8E;AAE9E,MAAM,UAAU,eAAe,CAAC,EAAY,EAAE,IAA6B;IACzE,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAoC,CAAA;IAErE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAyB,CAAA;QAClE,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAwB,EAAE,EAAE,CAAC,CAAC,CAAA;QACpF,OAAM;IACR,CAAC;IAED,IAAI,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAA;IACtD,CAAC;AACH,CAAC;AAED,SAAS,SAAS,CAAC,IAAyB,EAAE,EAAY;IACxD,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,GAAG,EAAE,GAAG,EAAE;YACR,MAAM,MAAM,GAAG,EAAE,EAAE,CAAA;YACnB,IAAI,CAAC,OAAO,GAAG,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7D,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/hooks/useMemo.d.ts

@@ -0,0 +1,2 @@
+export declare function useMemo<T>(factory: () => T, _deps?: ReadonlyArray<unknown>): () => T;
+//# sourceMappingURL=useMemo.d.ts.map

package/dist/hooks/useMemo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemo.d.ts","sourceRoot":"","sources":["../../src/hooks/useMemo.ts"],"names":[],"mappings":"AAcA,wBAAgB,OAAO,CAAC,CAAC,EACvB,OAAO,EAAE,MAAM,CAAC,EAChB,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B,MAAM,CAAC,CAUT"}

package/dist/hooks/useMemo.js

@@ -0,0 +1,18 @@
+import { computed } from '@rrjs/signals';
+import { getCurrentInstance } from '../instance';
+// useMemo wraps the factory in computed(), which auto-tracks signal reads.
+// Returns the GETTER, not the value — for the same reason useState does.
+// This allows chained useMemo and downstream effects to track changes.
+//
+// Inside JSX, the Babel plugin and the renderer's auto-unwrap make this transparent.
+// Outside JSX, the developer calls the returned function: doubled().
+export function useMemo(factory, _deps) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    if (instance.hooks[i] === undefined) {
+        const getter = computed(factory);
+        instance.hooks[i] = { getter };
+    }
+    return instance.hooks[i].getter;
+}
+//# sourceMappingURL=useMemo.js.map

package/dist/hooks/useMemo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemo.js","sourceRoot":"","sources":["../../src/hooks/useMemo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAMhD,2EAA2E;AAC3E,yEAAyE;AACzE,uEAAuE;AACvE,EAAE;AACF,qFAAqF;AACrF,qEAAqE;AAErE,MAAM,UAAU,OAAO,CACrB,OAAgB,EAChB,KAA8B;IAE9B,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;QAChC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,EAAoB,CAAA;IAClD,CAAC;IAED,OAAQ,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAoB,CAAC,MAAM,CAAA;AACrD,CAAC"}

package/dist/hooks/useReducer.d.ts

@@ -0,0 +1,6 @@
+type Reducer<S, A> = (state: S, action: A) => S;
+type Dispatch<A> = (action: A) => void;
+export declare function useReducer<S, A>(reducer: Reducer<S, A>, initialState: S): [() => S, Dispatch<A>];
+export declare function useReducer<S, A, I>(reducer: Reducer<S, A>, initialArg: I, init: (arg: I) => S): [() => S, Dispatch<A>];
+export {};
+//# sourceMappingURL=useReducer.d.ts.map

package/dist/hooks/useReducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReducer.d.ts","sourceRoot":"","sources":["../../src/hooks/useReducer.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,CAAA;AAC/C,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAA;AAuBtC,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,YAAY,EAAE,CAAC,GACd,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AACzB,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,UAAU,EAAE,CAAC,EACb,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAClB,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA"}

package/dist/hooks/useReducer.js

@@ -0,0 +1,21 @@
+import { createSignal } from '@rrjs/signals';
+import { getCurrentInstance } from '../instance';
+export function useReducer(reducer, initialArg, init) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    if (instance.hooks[i] === undefined) {
+        // Lazy initialisation if init is provided
+        // useReducer(reducer, props.initial, (initial) => ({ count: initial }))
+        const initialState = init !== undefined ? init(initialArg) : initialArg;
+        const [getter, setter] = createSignal(initialState);
+        const dispatch = (action) => {
+            const currentState = getter();
+            const nextState = reducer(currentState, action);
+            setter(nextState);
+        };
+        instance.hooks[i] = { getter, dispatch };
+    }
+    const hook = instance.hooks[i];
+    return [hook.getter, hook.dispatch];
+}
+//# sourceMappingURL=useReducer.js.map

package/dist/hooks/useReducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReducer.js","sourceRoot":"","sources":["../../src/hooks/useReducer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAmChD,MAAM,UAAU,UAAU,CACxB,OAAsB,EACtB,UAAe,EACf,IAAsB;IAEtB,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACpC,0CAA0C;QAC1C,wEAAwE;QACxE,MAAM,YAAY,GAAM,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAA;QAE1E,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAI,YAAY,CAAC,CAAA;QAEtD,MAAM,QAAQ,GAAgB,CAAC,MAAS,EAAE,EAAE;YAC1C,MAAM,YAAY,GAAG,MAAM,EAAE,CAAA;YAC7B,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;YAC/C,MAAM,CAAC,SAAS,CAAC,CAAA;QACnB,CAAC,CAAA;QAED,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAA0B,CAAA;IAClE,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAyB,CAAA;IACtD,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;AACrC,CAAC"}

package/dist/hooks/useRef.d.ts

@@ -0,0 +1,5 @@
+export interface RefObject<T> {
+    current: T;
+}
+export declare function useRef<T>(initial: T): RefObject<T>;
+//# sourceMappingURL=useRef.d.ts.map

package/dist/hooks/useRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRef.d.ts","sourceRoot":"","sources":["../../src/hooks/useRef.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,OAAO,EAAE,CAAC,CAAA;CACX;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAUlD"}

package/dist/hooks/useRef.js

@@ -0,0 +1,11 @@
+import { getCurrentInstance } from '../instance';
+export function useRef(initial) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    if (instance.hooks[i] === undefined) {
+        // First render — create the ref box
+        instance.hooks[i] = { current: initial };
+    }
+    return instance.hooks[i];
+}
+//# sourceMappingURL=useRef.js.map

package/dist/hooks/useRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRef.js","sourceRoot":"","sources":["../../src/hooks/useRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAMhD,MAAM,UAAU,MAAM,CAAI,OAAU;IAClC,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACpC,oCAAoC;QACpC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;IAC1C,CAAC;IAED,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAC1B,CAAC"}

package/dist/hooks/useState.d.ts

@@ -0,0 +1,4 @@
+type SetStateAction<T> = T | ((prev: T) => T);
+export declare function useState<T>(initial: T | (() => T)): [() => T, (action: SetStateAction<T>) => void];
+export {};
+//# sourceMappingURL=useState.d.ts.map

package/dist/hooks/useState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.d.ts","sourceRoot":"","sources":["../../src/hooks/useState.ts"],"names":[],"mappings":"AAgBA,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;AAQ7C,wBAAgB,QAAQ,CAAC,CAAC,EACxB,OAAO,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GACrB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CA+BhD"}

package/dist/hooks/useState.js

@@ -0,0 +1,29 @@
+import { createSignal } from '@rrjs/signals';
+import { getCurrentInstance } from '../instance';
+export function useState(initial) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    if (instance.hooks[i] === undefined) {
+        const initialValue = typeof initial === 'function'
+            ? initial()
+            : initial;
+        const [getter, setter] = createSignal(initialValue);
+        // The dispatch wrapper handles the functional updater form.
+        // setCount(c => c + 1) reads the current value through the getter,
+        // applies the updater, and writes the result.
+        const dispatch = (action) => {
+            if (typeof action === 'function') {
+                setter(action(getter()));
+            }
+            else {
+                setter(action);
+            }
+        };
+        instance.hooks[i] = { getter, setter, dispatch };
+    }
+    const hook = instance.hooks[i];
+    // Return the getter, not the value.
+    // The first element of the tuple is a function: count is () => number.
+    return [hook.getter, hook.dispatch];
+}
+//# sourceMappingURL=useState.js.map

package/dist/hooks/useState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.js","sourceRoot":"","sources":["../../src/hooks/useState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAuBhD,MAAM,UAAU,QAAQ,CACtB,OAAsB;IAEtB,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACpC,MAAM,YAAY,GAChB,OAAO,OAAO,KAAK,UAAU;YAC3B,CAAC,CAAE,OAAmB,EAAE;YACxB,CAAC,CAAC,OAAO,CAAA;QAEb,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAI,YAAY,CAAC,CAAA;QAEtD,4DAA4D;QAC5D,mEAAmE;QACnE,8CAA8C;QAC9C,MAAM,QAAQ,GAAG,CAAC,MAAyB,EAAQ,EAAE;YACnD,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;gBACjC,MAAM,CAAE,MAAyB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;YAC9C,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,MAAM,CAAC,CAAA;YAChB,CAAC;QACH,CAAC,CAAA;QAED,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAqB,CAAA;IACrE,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAoB,CAAA;IAEjD,oCAAoC;IACpC,uEAAuE;IACvE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;AACrC,CAAC"}

package/dist/hooks/useSyncExternalStore.d.ts

@@ -0,0 +1,4 @@
+type Subscribe = (onStoreChange: () => void) => () => void;
+export declare function useSyncExternalStore<T>(subscribe: Subscribe, getSnapshot: () => T, _getServerSnapshot?: () => T): () => T;
+export {};
+//# sourceMappingURL=useSyncExternalStore.d.ts.map

package/dist/hooks/useSyncExternalStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncExternalStore.d.ts","sourceRoot":"","sources":["../../src/hooks/useSyncExternalStore.ts"],"names":[],"mappings":"AAGA,KAAK,SAAS,GAAG,CAAC,aAAa,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;AA2B1D,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,MAAM,CAAC,EACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,CAwBT"}

package/dist/hooks/useSyncExternalStore.js

@@ -0,0 +1,41 @@
+import { createSignal } from '@rrjs/signals';
+import { getCurrentInstance } from '../instance';
+// useSyncExternalStore is the React 18+ primitive that lets external state
+// libraries (Redux, Zustand, Jotai, etc.) plug into a React-compatible
+// rendering system.
+//
+// The contract:
+//   - subscribe(callback): the store calls `callback` whenever its value changes,
+//     and returns a function that unsubscribes the callback.
+//   - getSnapshot(): returns the current value synchronously.
+//
+// Our implementation bridges this to the signal world:
+//   1. Read the initial snapshot.
+//   2. Create a signal seeded with that snapshot.
+//   3. Subscribe to the store. When it notifies, read a fresh snapshot
+//      and write it into the signal.
+//   4. Return the signal's getter — components that read it auto-track.
+//
+// The third argument (getServerSnapshot) is accepted for API compatibility.
+// We use it only for the initial value if we're in an SSR context — which
+// we don't currently support, so we just ignore it client-side.
+export function useSyncExternalStore(subscribe, getSnapshot, _getServerSnapshot) {
+    const instance = getCurrentInstance();
+    const i = instance.hookIndex++;
+    if (instance.hooks[i] === undefined) {
+        // Initial mount: snapshot, signal, subscription
+        const [getter, setter] = createSignal(getSnapshot());
+        const onStoreChange = () => {
+            const next = getSnapshot();
+            // The signal's same-value bailout handles unchanged snapshots correctly:
+            // Object.is(prev, next) means no notification fires, no DOM thrash.
+            setter(next);
+        };
+        const unsubscribe = subscribe(onStoreChange);
+        // Register cleanup to unsubscribe when the component unmounts.
+        instance.cleanup.push(unsubscribe);
+        instance.hooks[i] = { getter, unsubscribe };
+    }
+    return instance.hooks[i].getter;
+}
+//# sourceMappingURL=useSyncExternalStore.js.map

package/dist/hooks/useSyncExternalStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncExternalStore.js","sourceRoot":"","sources":["../../src/hooks/useSyncExternalStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAU,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAShD,2EAA2E;AAC3E,uEAAuE;AACvE,oBAAoB;AACpB,EAAE;AACF,gBAAgB;AAChB,kFAAkF;AAClF,6DAA6D;AAC7D,8DAA8D;AAC9D,EAAE;AACF,uDAAuD;AACvD,kCAAkC;AAClC,kDAAkD;AAClD,uEAAuE;AACvE,qCAAqC;AACrC,wEAAwE;AACxE,EAAE;AACF,4EAA4E;AAC5E,0EAA0E;AAC1E,gEAAgE;AAEhE,MAAM,UAAU,oBAAoB,CAClC,SAAoB,EACpB,WAAoB,EACpB,kBAA4B;IAE5B,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAA;IACrC,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACpC,gDAAgD;QAChD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAI,WAAW,EAAE,CAAC,CAAA;QAEvD,MAAM,aAAa,GAAG,GAAG,EAAE;YACzB,MAAM,IAAI,GAAG,WAAW,EAAE,CAAA;YAC1B,yEAAyE;YACzE,oEAAoE;YACpE,MAAM,CAAC,IAAI,CAAC,CAAA;QACd,CAAC,CAAA;QAED,MAAM,WAAW,GAAG,SAAS,CAAC,aAAa,CAAC,CAAA;QAE5C,+DAA+D;QAC/D,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAElC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAiC,CAAA;IAC5E,CAAC;IAED,OAAQ,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAiC,CAAC,MAAM,CAAA;AAClE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { useRef } from './hooks/useRef';
+export type { RefObject } from './hooks/useRef';
+export { useState } from './hooks/useState';
+export { useReducer } from './hooks/useReducer';
+export { useMemo } from './hooks/useMemo';
+export { useCallback } from './hooks/useCallback';
+export { useEffect } from './hooks/useEffect';
+export { useLayoutEffect } from './hooks/useLayoutEffect';
+export { useContext } from './hooks/useContext';
+export { useId } from './hooks/useId';
+export { useImperativeHandle } from './hooks/useImperativeHandle';
+export { useSyncExternalStore } from './hooks/useSyncExternalStore';
+export { useTransition, useDeferredValue, useInsertionEffect, useDebugValue, } from './hooks/noop-hooks';
+export { forwardRef, isForwardRef, FORWARD_REF } from './forwardRef';
+export type { Ref, ForwardRefComponent } from './forwardRef';
+export { createContext, withProvider, pushContext, popContext, } from './context';
+export type { Context } from './context';
+export { createInstance, withInstance, getCurrentInstance, setCurrentInstance, flushLayoutEffects, flushPassiveEffects, } from './instance';
+export type { ComponentInstance, EffectEntry } from './instance';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACvC,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAGnE,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,GACd,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACpE,YAAY,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAE5D,OAAO,EACL,aAAa,EACb,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,WAAW,CAAA;AAClB,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAExC,OAAO,EACL,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+export { useRef } from './hooks/useRef';
+export { useState } from './hooks/useState';
+export { useReducer } from './hooks/useReducer';
+export { useMemo } from './hooks/useMemo';
+export { useCallback } from './hooks/useCallback';
+export { useEffect } from './hooks/useEffect';
+export { useLayoutEffect } from './hooks/useLayoutEffect';
+export { useContext } from './hooks/useContext';
+export { useId } from './hooks/useId';
+export { useImperativeHandle } from './hooks/useImperativeHandle';
+export { useSyncExternalStore } from './hooks/useSyncExternalStore';
+// Documented no-ops — Tier 3 in the compatibility contract
+export { useTransition, useDeferredValue, useInsertionEffect, useDebugValue, } from './hooks/noop-hooks';
+export { forwardRef, isForwardRef, FORWARD_REF } from './forwardRef';
+export { createContext, withProvider, pushContext, popContext, } from './context';
+export { createInstance, withInstance, getCurrentInstance, setCurrentInstance, flushLayoutEffects, flushPassiveEffects, } from './instance';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAGvC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAEnE,2DAA2D;AAC3D,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,GACd,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAGpE,OAAO,EACL,aAAa,EACb,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,WAAW,CAAA;AAGlB,OAAO,EACL,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,YAAY,CAAA"}

package/dist/instance.d.ts

@@ -0,0 +1,18 @@
+export interface ComponentInstance {
+    hooks: any[];
+    hookIndex: number;
+    layoutEffects: EffectEntry[];
+    passiveEffects: EffectEntry[];
+    cleanup: Array<() => void>;
+}
+export interface EffectEntry {
+    run: () => void;
+    cleanup: (() => void) | null;
+}
+export declare function getCurrentInstance(): ComponentInstance;
+export declare function setCurrentInstance(instance: ComponentInstance | null): void;
+export declare function createInstance(): ComponentInstance;
+export declare function withInstance<T>(instance: ComponentInstance, fn: () => T): T;
+export declare function flushLayoutEffects(instance: ComponentInstance): void;
+export declare function flushPassiveEffects(instance: ComponentInstance): void;
+//# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,iBAAiB;IAEhC,KAAK,EAAE,GAAG,EAAE,CAAA;IAEZ,SAAS,EAAE,MAAM,CAAA;IAEjB,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,cAAc,EAAE,WAAW,EAAE,CAAA;IAE7B,OAAO,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,IAAI,CAAA;IACf,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;CAC7B;AASD,wBAAgB,kBAAkB,IAAI,iBAAiB,CAQtD;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAE3E;AAID,wBAAgB,cAAc,IAAI,iBAAiB,CAQlD;AAQD,wBAAgB,YAAY,CAAC,CAAC,EAC5B,QAAQ,EAAE,iBAAiB,EAC3B,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CASH;AAsBD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAapE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAerE"}

package/dist/instance.js

@@ -0,0 +1,87 @@
+// ─── Types ──────────────────────────────────────────────────────────────────
+// ─── The current rendering instance ─────────────────────────────────────────
+// While a component function is running, this holds the instance whose hooks
+// should be allocated to the next hook call. After the function returns,
+// it goes back to null.
+let currentInstance = null;
+export function getCurrentInstance() {
+    if (!currentInstance) {
+        throw new Error('Hook called outside of a component. ' +
+            'Hooks can only be called inside the body of a component function.');
+    }
+    return currentInstance;
+}
+export function setCurrentInstance(instance) {
+    currentInstance = instance;
+}
+// ─── Create a new component instance ────────────────────────────────────────
+export function createInstance() {
+    return {
+        hooks: [],
+        hookIndex: 0,
+        layoutEffects: [],
+        passiveEffects: [],
+        cleanup: [],
+    };
+}
+// ─── Render lifecycle ───────────────────────────────────────────────────────
+// Wraps a component function call with the proper instance setup.
+// hookIndex resets to 0 — this is critical.
+// If anything triggers a re-run (rare in our signal model but possible),
+// hooks must be allocated from the same array slots, in the same order.
+export function withInstance(instance, fn) {
+    const prev = currentInstance;
+    setCurrentInstance(instance);
+    instance.hookIndex = 0;
+    try {
+        return fn();
+    }
+    finally {
+        setCurrentInstance(prev);
+    }
+}
+// ─── Effect flushing ────────────────────────────────────────────────────────
+// Called by the renderer after a component has finished its render phase
+// and DOM mutations are committed. This is the "commit phase" equivalent.
+//
+// Layout effects run synchronously, before paint.
+// Passive effects are scheduled via MessageChannel — they run in a new macro
+// task after the browser has had the chance to paint.
+// MessageChannel is the same mechanism React's Scheduler uses for the same reason:
+// queueMicrotask runs BEFORE paint (microtask checkpoint), which is wrong for useEffect.
+// MessageChannel posts a message that delivers in the NEXT macro task, after paint.
+const channel = new MessageChannel();
+const pendingPassiveFlushes = [];
+channel.port1.onmessage = () => {
+    const flushes = pendingPassiveFlushes.splice(0);
+    for (const flush of flushes)
+        flush();
+};
+export function flushLayoutEffects(instance) {
+    // Run synchronously. Cleanup of previous effect, then run new effect.
+    // Order matters: all cleanups for stale effects fire before any new effect runs.
+    // We separate into two passes to match React's behavior.
+    const entries = instance.layoutEffects;
+    instance.layoutEffects = [];
+    for (const entry of entries) {
+        entry.cleanup?.();
+    }
+    for (const entry of entries) {
+        entry.run();
+    }
+}
+export function flushPassiveEffects(instance) {
+    // Schedule, don't run. Effects run in the next macro task — after paint.
+    pendingPassiveFlushes.push(() => {
+        const entries = instance.passiveEffects;
+        instance.passiveEffects = [];
+        for (const entry of entries) {
+            entry.cleanup?.();
+        }
+        for (const entry of entries) {
+            entry.run();
+        }
+    });
+    channel.port2.postMessage(null);
+}
+//# sourceMappingURL=instance.js.map

package/dist/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAmB/E,+EAA+E;AAC/E,6EAA6E;AAC7E,yEAAyE;AACzE,wBAAwB;AAExB,IAAI,eAAe,GAA6B,IAAI,CAAA;AAEpD,MAAM,UAAU,kBAAkB;IAChC,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,sCAAsC;YACtC,mEAAmE,CACpE,CAAA;IACH,CAAC;IACD,OAAO,eAAe,CAAA;AACxB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,QAAkC;IACnE,eAAe,GAAG,QAAQ,CAAA;AAC5B,CAAC;AAED,+EAA+E;AAE/E,MAAM,UAAU,cAAc;IAC5B,OAAO;QACL,KAAK,EAAE,EAAE;QACT,SAAS,EAAE,CAAC;QACZ,aAAa,EAAE,EAAE;QACjB,cAAc,EAAE,EAAE;QAClB,OAAO,EAAE,EAAE;KACZ,CAAA;AACH,CAAC;AAED,+EAA+E;AAC/E,kEAAkE;AAClE,4CAA4C;AAC5C,yEAAyE;AACzE,wEAAwE;AAExE,MAAM,UAAU,YAAY,CAC1B,QAA2B,EAC3B,EAAW;IAEX,MAAM,IAAI,GAAG,eAAe,CAAA;IAC5B,kBAAkB,CAAC,QAAQ,CAAC,CAAA;IAC5B,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAA;IACtB,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,CAAA;IACb,CAAC;YAAS,CAAC;QACT,kBAAkB,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;AACH,CAAC;AAGD,+EAA+E;AAC/E,yEAAyE;AACzE,0EAA0E;AAC1E,EAAE;AACF,kDAAkD;AAClD,6EAA6E;AAC7E,sDAAsD;AAEtD,mFAAmF;AACnF,yFAAyF;AACzF,oFAAoF;AACpF,MAAM,OAAO,GAAG,IAAI,cAAc,EAAE,CAAA;AACpC,MAAM,qBAAqB,GAAsB,EAAE,CAAA;AAEnD,OAAO,CAAC,KAAK,CAAC,SAAS,GAAG,GAAG,EAAE;IAC7B,MAAM,OAAO,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAC/C,KAAK,MAAM,KAAK,IAAI,OAAO;QAAE,KAAK,EAAE,CAAA;AACtC,CAAC,CAAA;AAED,MAAM,UAAU,kBAAkB,CAAC,QAA2B;IAC5D,sEAAsE;IACtE,iFAAiF;IACjF,yDAAyD;IACzD,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAA;IACtC,QAAQ,CAAC,aAAa,GAAG,EAAE,CAAA;IAE3B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,KAAK,CAAC,OAAO,EAAE,EAAE,CAAA;IACnB,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,KAAK,CAAC,GAAG,EAAE,CAAA;IACb,CAAC;AACH,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,QAA2B;IAC7D,yEAAyE;IACzE,qBAAqB,CAAC,IAAI,CAAC,GAAG,EAAE;QAC9B,MAAM,OAAO,GAAG,QAAQ,CAAC,cAAc,CAAA;QACvC,QAAQ,CAAC,cAAc,GAAG,EAAE,CAAA;QAE5B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,KAAK,CAAC,OAAO,EAAE,EAAE,CAAA;QACnB,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,KAAK,CAAC,GAAG,EAAE,CAAA;QACb,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;AACjC,CAAC"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@rrjs/react-compat",
+  "version": "0.1.0",
+  "description": "React hooks API on top of signals: useState, useEffect, useReducer, useContext, and more",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@rrjs/signals": "^0.1.0"
+  },
+  "devDependencies": {
+    "vitest": "^1.0.0",
+    "jsdom": "^24.0.0",
+    "typescript": "^5.0.0"
+  },
+  "license": "MIT",
+  "author": "Saman Abaasi <samabaasii@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SamAbaasi/reactive-react.git",
+    "directory": "packages/react-compat"
+  },
+  "keywords": ["react", "hooks", "compatibility", "signals", "useState", "useEffect"]
+}