rnwind 0.0.1 → 0.0.2

package/lib/cjs/runtime/components/rnwind-provider.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var reactNative = require('react-native');
+var lookupCss = require('../lookup-css.cjs');
+
+const EMPTY_TABLES = {};
+const ZERO_INSETS = { top: 0, right: 0, bottom: 0, left: 0 };
+const DEFAULT_STATE = {
+    scheme: 'light',
+    tables: EMPTY_TABLES,
+    insets: ZERO_INSETS,
+    onHaptics: undefined,
+    fontScale: 1,
+    windowWidth: 0,
+    activeBreakpoint: lookupCss.BASE_BREAKPOINT,
+};
+/**
+ * Normalise a `Partial<Insets>` into a complete {@link Insets}, returning
+ * the shared {@link ZERO_INSETS} reference when nothing is supplied so
+ * downstream memoisation stays stable.
+ * @param partial Caller-supplied insets (or undefined).
+ * @returns Complete insets record.
+ */
+function normaliseInsets(partial) {
+    if (!partial)
+        return ZERO_INSETS;
+    const top = partial.top ?? 0;
+    const right = partial.right ?? 0;
+    const bottom = partial.bottom ?? 0;
+    const left = partial.left ?? 0;
+    if (top === 0 && right === 0 && bottom === 0 && left === 0)
+        return ZERO_INSETS;
+    return { top, right, bottom, left };
+}
+/** Single internal context the runtime reads from. */
+const RnwindContext = React.createContext(DEFAULT_STATE);
+/**
+ * Read rnwind's full runtime state — scheme, theme tables, insets,
+ * fontScale, windowWidth, onHaptics — in one go. Pass the returned
+ * value straight to `lookupCss` / `useCss`, or destructure what you
+ * need.
+ * @returns Active rnwind state under the nearest {@link RnwindProvider}.
+ */
+function useRnwind() {
+    return React.useContext(RnwindContext);
+}
+/**
+ * Internal context hook the babel transformer injects at the top of
+ * every rewritten component as `const _t = useR_()`. Same body as the
+ * public {@link useRnwind} — exposed under a `use*`-prefixed name so
+ * react-refresh's babel plugin (which only tracks call-sites whose
+ * identifier matches `^use[A-Z]`) folds it into each component's
+ * fast-refresh signature. Without that prefix the signature stayed
+ * stable across transformer changes; HMR then preserved fiber state
+ * while the rendered hook list shifted, surfacing as "change in the
+ * order of Hooks" runtime errors. Trailing underscore keeps it
+ * visually distinct from the user-facing `useRnwind`.
+ * @returns Active rnwind state.
+ */
+function useR_() {
+    return React.useContext(RnwindContext);
+}
+/**
+ * Provider for rnwind's full runtime state. fontScale + windowWidth
+ * come from `useWindowDimensions()` so they react to OS-level
+ * orientation / accessibility-text-size changes automatically.
+ * @param props Provider props.
+ * @param props.scheme Active scheme name.
+ * @param props.tables Optional pre-resolved token tables.
+ * @param props.insets Optional safe-area insets.
+ * @param props.onHaptics Optional haptic dispatcher.
+ * @param props.children React subtree.
+ * @returns Provider element.
+ */
+function RnwindProvider({ scheme, tables, insets, onHaptics, children }) {
+    const normalized = normaliseInsets(insets);
+    const { fontScale, width } = reactNative.useWindowDimensions();
+    const value = React.useMemo(() => {
+        lookupCss.loadScheme(scheme);
+        return {
+            scheme,
+            tables: tables ?? EMPTY_TABLES,
+            insets: normalized,
+            onHaptics,
+            fontScale,
+            windowWidth: width,
+            activeBreakpoint: lookupCss.activeBreakpointFor(width),
+        };
+    }, [scheme, tables, normalized, onHaptics, fontScale, width]);
+    return jsxRuntime.jsx(RnwindContext.Provider, { value: value, children: children });
+}
+
+exports.RnwindProvider = RnwindProvider;
+exports.useR_ = useR_;
+exports.useRnwind = useRnwind;
+//# sourceMappingURL=rnwind-provider.cjs.map

package/lib/cjs/runtime/components/rnwind-provider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rnwind-provider.cjs","sources":["../../../../../src/runtime/components/rnwind-provider.tsx"],"sourcesContent":["import { createContext, useContext, useMemo, type ReactNode } from 'react'\nimport { useWindowDimensions } from 'react-native'\nimport type { ThemeTables } from '../../core/types'\nimport type { Scheme } from '../types'\nimport type { OnHaptics } from '../../core/parser/haptics'\nimport { activeBreakpointFor, BASE_BREAKPOINT, loadScheme } from '../lookup-css'\n\n/**\n * Per-render safe-area insets snapshot. Bridge from any source\n * (`useSafeAreaInsets()`, expo-router insets, a manually computed\n * value) into the {@link RnwindProvider} — rnwind stays\n * library-agnostic.\n */\nexport type Insets = Readonly<{\n  top: number\n  right: number\n  bottom: number\n  left: number\n}>\n\n/**\n * Single value carried by the rnwind context. Every piece of runtime\n * state rnwind needs — scheme, theme tables, insets, font scale,\n * window width, active responsive breakpoint, optional haptic\n * dispatcher — lives on this one bag. Consumers read it via\n * {@link useRnwind} and either destructure or forward straight to\n * `lookupCss` / `useCss`.\n *\n * `activeBreakpoint` is the highest-threshold registered breakpoint\n * whose min-width is `<= windowWidth`, or `'base'` when below the\n * smallest one (mobile-first tier) or when no breakpoints are\n * registered yet (tests, bundles without rnwind-transformed sources).\n * Always a string — never null. Reactive: it updates with\n * `useWindowDimensions().width`, so consumers can branch on it\n * without a separate hook.\n */\nexport type RnwindState = Readonly<{\n  scheme: Scheme\n  tables: ThemeTables\n  insets: Insets\n  onHaptics: OnHaptics | undefined\n  fontScale: number\n  windowWidth: number\n  activeBreakpoint: string\n}>\n\n/** Props accepted by {@link RnwindProvider}. */\nexport type RnwindProviderProps = Readonly<{\n  scheme: Scheme\n  tables?: ThemeTables\n  insets?: Partial<Insets>\n  onHaptics?: OnHaptics\n  children?: ReactNode\n}>\n\nconst EMPTY_TABLES: ThemeTables = {}\nconst ZERO_INSETS: Insets = { top: 0, right: 0, bottom: 0, left: 0 }\nconst DEFAULT_STATE: RnwindState = {\n  scheme: 'light' as Scheme,\n  tables: EMPTY_TABLES,\n  insets: ZERO_INSETS,\n  onHaptics: undefined,\n  fontScale: 1,\n  windowWidth: 0,\n  activeBreakpoint: BASE_BREAKPOINT,\n}\n\n/**\n * Normalise a `Partial<Insets>` into a complete {@link Insets}, returning\n * the shared {@link ZERO_INSETS} reference when nothing is supplied so\n * downstream memoisation stays stable.\n * @param partial Caller-supplied insets (or undefined).\n * @returns Complete insets record.\n */\nfunction normaliseInsets(partial: Partial<Insets> | undefined): Insets {\n  if (!partial) return ZERO_INSETS\n  const top = partial.top ?? 0\n  const right = partial.right ?? 0\n  const bottom = partial.bottom ?? 0\n  const left = partial.left ?? 0\n  if (top === 0 && right === 0 && bottom === 0 && left === 0) return ZERO_INSETS\n  return { top, right, bottom, left }\n}\n\n/** Single internal context the runtime reads from. */\nconst RnwindContext = createContext<RnwindState>(DEFAULT_STATE)\n\n/**\n * Read rnwind's full runtime state — scheme, theme tables, insets,\n * fontScale, windowWidth, onHaptics — in one go. Pass the returned\n * value straight to `lookupCss` / `useCss`, or destructure what you\n * need.\n * @returns Active rnwind state under the nearest {@link RnwindProvider}.\n */\nexport function useRnwind(): RnwindState {\n  return useContext(RnwindContext)\n}\n\n/**\n * Internal context hook the babel transformer injects at the top of\n * every rewritten component as `const _t = useR_()`. Same body as the\n * public {@link useRnwind} — exposed under a `use*`-prefixed name so\n * react-refresh's babel plugin (which only tracks call-sites whose\n * identifier matches `^use[A-Z]`) folds it into each component's\n * fast-refresh signature. Without that prefix the signature stayed\n * stable across transformer changes; HMR then preserved fiber state\n * while the rendered hook list shifted, surfacing as \"change in the\n * order of Hooks\" runtime errors. Trailing underscore keeps it\n * visually distinct from the user-facing `useRnwind`.\n * @returns Active rnwind state.\n */\nexport function useR_(): RnwindState {\n  return useContext(RnwindContext)\n}\n\n/**\n * Provider for rnwind's full runtime state. fontScale + windowWidth\n * come from `useWindowDimensions()` so they react to OS-level\n * orientation / accessibility-text-size changes automatically.\n * @param props Provider props.\n * @param props.scheme Active scheme name.\n * @param props.tables Optional pre-resolved token tables.\n * @param props.insets Optional safe-area insets.\n * @param props.onHaptics Optional haptic dispatcher.\n * @param props.children React subtree.\n * @returns Provider element.\n */\nexport function RnwindProvider({ scheme, tables, insets, onHaptics, children }: RnwindProviderProps): ReactNode {\n  const normalized = normaliseInsets(insets)\n  const { fontScale, width } = useWindowDimensions()\n  const value = useMemo<RnwindState>(() => {\n    loadScheme(scheme)\n    return {\n      scheme,\n      tables: tables ?? EMPTY_TABLES,\n      insets: normalized,\n      onHaptics,\n      fontScale,\n      windowWidth: width,\n      activeBreakpoint: activeBreakpointFor(width),\n    }\n  }, [scheme, tables, normalized, onHaptics, fontScale, width])\n  return <RnwindContext.Provider value={value}>{children}</RnwindContext.Provider>\n}\n"],"names":["BASE_BREAKPOINT","createContext","useContext","useWindowDimensions","useMemo","loadScheme","activeBreakpointFor","_jsx"],"mappings":";;;;;;;AAuDA,MAAM,YAAY,GAAgB,EAAE;AACpC,MAAM,WAAW,GAAW,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;AACpE,MAAM,aAAa,GAAgB;AACjC,IAAA,MAAM,EAAE,OAAiB;AACzB,IAAA,MAAM,EAAE,YAAY;AACpB,IAAA,MAAM,EAAE,WAAW;AACnB,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,WAAW,EAAE,CAAC;AACd,IAAA,gBAAgB,EAAEA,yBAAe;CAClC;AAED;;;;;;AAMG;AACH,SAAS,eAAe,CAAC,OAAoC,EAAA;AAC3D,IAAA,IAAI,CAAC,OAAO;AAAE,QAAA,OAAO,WAAW;AAChC,IAAA,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;AAC5B,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC;AAChC,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;AAClC,IAAA,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,CAAC;AAC9B,IAAA,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;AAAE,QAAA,OAAO,WAAW;IAC9E,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;AACrC;AAEA;AACA,MAAM,aAAa,GAAGC,mBAAa,CAAc,aAAa,CAAC;AAE/D;;;;;;AAMG;SACa,SAAS,GAAA;AACvB,IAAA,OAAOC,gBAAU,CAAC,aAAa,CAAC;AAClC;AAEA;;;;;;;;;;;;AAYG;SACa,KAAK,GAAA;AACnB,IAAA,OAAOA,gBAAU,CAAC,aAAa,CAAC;AAClC;AAEA;;;;;;;;;;;AAWG;AACG,SAAU,cAAc,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAuB,EAAA;AACjG,IAAA,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GAAGC,+BAAmB,EAAE;AAClD,IAAA,MAAM,KAAK,GAAGC,aAAO,CAAc,MAAK;QACtCC,oBAAU,CAAC,MAAM,CAAC;QAClB,OAAO;YACL,MAAM;YACN,MAAM,EAAE,MAAM,IAAI,YAAY;AAC9B,YAAA,MAAM,EAAE,UAAU;YAClB,SAAS;YACT,SAAS;AACT,YAAA,WAAW,EAAE,KAAK;AAClB,YAAA,gBAAgB,EAAEC,6BAAmB,CAAC,KAAK,CAAC;SAC7C;AACH,IAAA,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC7D,OAAOC,cAAA,CAAC,aAAa,CAAC,QAAQ,EAAA,EAAC,KAAK,EAAE,KAAK,EAAA,QAAA,EAAG,QAAQ,EAAA,CAA0B;AAClF;;;;;;"}

package/lib/cjs/runtime/components/rnwind-provider.d.ts

@@ -0,0 +1,84 @@
+import { type ReactNode } from 'react';
+import type { ThemeTables } from '../../core/types';
+import type { Scheme } from '../types';
+import type { OnHaptics } from '../../core/parser/haptics';
+/**
+ * Per-render safe-area insets snapshot. Bridge from any source
+ * (`useSafeAreaInsets()`, expo-router insets, a manually computed
+ * value) into the {@link RnwindProvider} — rnwind stays
+ * library-agnostic.
+ */
+export type Insets = Readonly<{
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}>;
+/**
+ * Single value carried by the rnwind context. Every piece of runtime
+ * state rnwind needs — scheme, theme tables, insets, font scale,
+ * window width, active responsive breakpoint, optional haptic
+ * dispatcher — lives on this one bag. Consumers read it via
+ * {@link useRnwind} and either destructure or forward straight to
+ * `lookupCss` / `useCss`.
+ *
+ * `activeBreakpoint` is the highest-threshold registered breakpoint
+ * whose min-width is `<= windowWidth`, or `'base'` when below the
+ * smallest one (mobile-first tier) or when no breakpoints are
+ * registered yet (tests, bundles without rnwind-transformed sources).
+ * Always a string — never null. Reactive: it updates with
+ * `useWindowDimensions().width`, so consumers can branch on it
+ * without a separate hook.
+ */
+export type RnwindState = Readonly<{
+    scheme: Scheme;
+    tables: ThemeTables;
+    insets: Insets;
+    onHaptics: OnHaptics | undefined;
+    fontScale: number;
+    windowWidth: number;
+    activeBreakpoint: string;
+}>;
+/** Props accepted by {@link RnwindProvider}. */
+export type RnwindProviderProps = Readonly<{
+    scheme: Scheme;
+    tables?: ThemeTables;
+    insets?: Partial<Insets>;
+    onHaptics?: OnHaptics;
+    children?: ReactNode;
+}>;
+/**
+ * Read rnwind's full runtime state — scheme, theme tables, insets,
+ * fontScale, windowWidth, onHaptics — in one go. Pass the returned
+ * value straight to `lookupCss` / `useCss`, or destructure what you
+ * need.
+ * @returns Active rnwind state under the nearest {@link RnwindProvider}.
+ */
+export declare function useRnwind(): RnwindState;
+/**
+ * Internal context hook the babel transformer injects at the top of
+ * every rewritten component as `const _t = useR_()`. Same body as the
+ * public {@link useRnwind} — exposed under a `use*`-prefixed name so
+ * react-refresh's babel plugin (which only tracks call-sites whose
+ * identifier matches `^use[A-Z]`) folds it into each component's
+ * fast-refresh signature. Without that prefix the signature stayed
+ * stable across transformer changes; HMR then preserved fiber state
+ * while the rendered hook list shifted, surfacing as "change in the
+ * order of Hooks" runtime errors. Trailing underscore keeps it
+ * visually distinct from the user-facing `useRnwind`.
+ * @returns Active rnwind state.
+ */
+export declare function useR_(): RnwindState;
+/**
+ * Provider for rnwind's full runtime state. fontScale + windowWidth
+ * come from `useWindowDimensions()` so they react to OS-level
+ * orientation / accessibility-text-size changes automatically.
+ * @param props Provider props.
+ * @param props.scheme Active scheme name.
+ * @param props.tables Optional pre-resolved token tables.
+ * @param props.insets Optional safe-area insets.
+ * @param props.onHaptics Optional haptic dispatcher.
+ * @param props.children React subtree.
+ * @returns Provider element.
+ */
+export declare function RnwindProvider({ scheme, tables, insets, onHaptics, children }: RnwindProviderProps): ReactNode;

package/lib/cjs/runtime/gradient-types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Typed contract for the component rnwind's transformer calls with a
+ * gradient-class `className`. Matches `expo-linear-gradient` verbatim
+ * so users can plug any gradient library that mirrors that API.
+ *
+ * A typical wiring:
+ *
+ * ```tsx
+ * import { LinearGradient } from 'expo-linear-gradient'
+ * import type { AsLinearGradientProps } from 'rnwind'
+ *
+ * // Assert at the type level — CI catches mismatches before runtime.
+ * const _typeCheck: AsLinearGradientProps = {} as Parameters<typeof LinearGradient>[0]
+ *
+ * // Then use it in real JSX. rnwind fills in colors / start / end.
+ * <LinearGradient className="bg-gradient-to-r from-red-500 to-blue-500" />
+ * ```
+ *
+ * The rnwind transformer emits `colors` as a frozen `readonly string[]`,
+ * and `start` / `end` as frozen `{x: number, y: number}` records.
+ * Users pass the component; rnwind fills the props. Unused props
+ * (`locations`, `dither`, …) are forwarded verbatim from the JSX site.
+ */
+/** A unit-square point. Matches the `LinearGradientPoint` object form. */
+export interface LinearGradientPoint {
+    /** Horizontal component, 0..1. */
+    readonly x: number;
+    /** Vertical component, 0..1. */
+    readonly y: number;
+}
+/**
+ * The exact prop shape rnwind fills onto a gradient component at
+ * build time. A user-supplied `<LinearGradient>` (or any other
+ * component) must accept these props — no wrapper, no adapter.
+ */
+export interface AsLinearGradientProps {
+    /**
+     * Gradient colour stops in source order. rnwind emits a frozen
+     * `readonly string[]` with 2+ entries (at least `from` + `to`).
+     * Compatible with expo-linear-gradient's `colors: readonly [ColorValue, ColorValue, ...ColorValue[]]`.
+     */
+    readonly colors: readonly string[];
+    /**
+     * Start point, in the unit square (0,0)=top-left → (1,1)=bottom-right.
+     * rnwind emits a frozen `{x, y}` record matching the Tailwind
+     * direction utility (`to-r` → `{x: 0, y: 0.5}`).
+     */
+    readonly start: LinearGradientPoint;
+    /** End point — same unit-square coordinates as `start`. */
+    readonly end: LinearGradientPoint;
+    /**
+     * Optional colour-stop positions matching `colors` length. rnwind
+     * doesn't emit this today (Tailwind v4's stop-position atoms aren't
+     * wired yet); listed here so the prop surface still matches
+     * expo-linear-gradient when a consumer passes their own.
+     */
+    readonly locations?: readonly number[] | null;
+}

package/lib/cjs/runtime/haptics.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+var React = require('react');
+var rnwindProvider = require('./components/rnwind-provider.cjs');
+
+/**
+ * Runtime helpers the transformer injects for haptic utilities.
+ *
+ * Two entry points:
+ *
+ *   useMountHaptic(requests) — fires each request on mount via
+ *     `useEffect(() => { ... }, [])`. Used by the transformer for bare
+ *     `haptic-*` atoms (no variant prefix).
+ *
+ *   triggerHaptic(onHaptics, request, trigger) — thin forwarding
+ *     helper for event-driven variants (`active:haptic-*`, `focus:...`,
+ *     `hover:...`). The transformer emits an inline arrow that calls
+ *     this from `onPressIn` / `onFocus` / etc.
+ *
+ * Both emit a one-shot dev-mode warning when `onHaptics` is missing —
+ * so developers get a clear "you forgot to wire <SchemeProvider
+ * onHaptics=...>" signal instead of silently dropping the haptic.
+ */
+/**
+ * Module-scope set tracking haptic trigger strings we've already
+ * warned about. Prevents the "missing onHaptics" warning from
+ * spamming the console when the same class appears on many elements.
+ */
+const WARNED_MISSING_HAPTICS = new Set();
+/**
+ * Render a `HapticRequest` as a short descriptive tag for log lines.
+ * @param request Haptic request.
+ * @returns `impact/Light`, `notification/Success`, or `selection`.
+ */
+function hapticTag(request) {
+    if (request.kind === 'impact')
+        return `impact/${request.style}`;
+    if (request.kind === 'notification')
+        return `notification/${request.type}`;
+    return 'selection';
+}
+/**
+ * Warn once per haptic trigger kind when a `haptic-*` atom tries to
+ * dispatch without an `onHaptics` provider. Dev-mode only — `__DEV__`
+ * is a Metro / Expo / RN global that compiles to `false` in release
+ * bundles, so no warn code ships to production.
+ * @param request The haptic request that had no provider.
+ * @param trigger The lifecycle trigger that tried to fire.
+ */
+function warnMissingOnHaptics(request, trigger) {
+    // `__DEV__` is a RN / Metro global — `false` in release, strips the
+    // branch entirely. Guarded in case we're evaluated outside of Metro
+    // (tests, node scripts) where the global isn't defined.
+    const isDevelopment = typeof __DEV__ === 'undefined' || __DEV__;
+    if (!isDevelopment)
+        return;
+    const tag = hapticTag(request);
+    const key = `${tag}@${trigger}`;
+    if (WARNED_MISSING_HAPTICS.has(key))
+        return;
+    WARNED_MISSING_HAPTICS.add(key);
+    // eslint-disable-next-line no-console
+    console.warn(`rnwind: a haptic utility fired (${tag}, trigger=${trigger}) but no onHaptics callback is wired on <SchemeProvider>. ` +
+        `Pass \`onHaptics\` on the provider to forward this to expo-haptics (or any library of your choice).`);
+}
+/**
+ * Invoke every request in `requests` on mount (once per component
+ * mount), using the `onHaptics` dispatcher from the nearest
+ * `<SchemeProvider>`. Missing-provider dev warnings fire via
+ * {@link warnMissingOnHaptics}.
+ *
+ * Uses `useEffect(..., [])` — the requests array is identity-stable
+ * (hoisted at module scope by the transformer), so re-firing on
+ * re-renders isn't a concern.
+ * @param requests Hoisted request list for this component.
+ */
+function useMountHaptic(requests) {
+    const { onHaptics } = rnwindProvider.useRnwind();
+    React.useEffect(() => {
+        for (const request of requests) {
+            if (onHaptics)
+                onHaptics(request, 'mount');
+            else
+                warnMissingOnHaptics(request, 'mount');
+        }
+        // requests is a hoisted stable reference — depending on onHaptics
+        // identity keeps the effect fresh if the provider remounts with a
+        // different dispatcher, while the hoisted const prevents a remount
+        // from an inline `onHaptics={(r) => ...}`.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [onHaptics]);
+}
+/**
+ * Fire one haptic request through the provider dispatcher. Emits the
+ * missing-provider dev warning when no dispatcher is wired. Designed
+ * for the inline arrows the transformer synthesises:
+ *
+ *   onPressIn={(e) => { triggerHaptic(_h, _HR_xxx, 'pressIn'); user?.(e) }}
+ * @param onHaptics Provider dispatcher (may be undefined).
+ * @param request Pre-hoisted request object.
+ * @param trigger Lifecycle trigger.
+ */
+function triggerHaptic(onHaptics, request, trigger) {
+    if (onHaptics) {
+        onHaptics(request, trigger);
+        return;
+    }
+    warnMissingOnHaptics(request, trigger);
+}
+
+exports.triggerHaptic = triggerHaptic;
+exports.useMountHaptic = useMountHaptic;
+//# sourceMappingURL=haptics.cjs.map

package/lib/cjs/runtime/haptics.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"haptics.cjs","sources":["../../../../src/runtime/haptics.ts"],"sourcesContent":["/**\n * Runtime helpers the transformer injects for haptic utilities.\n *\n * Two entry points:\n *\n *   useMountHaptic(requests) — fires each request on mount via\n *     `useEffect(() => { ... }, [])`. Used by the transformer for bare\n *     `haptic-*` atoms (no variant prefix).\n *\n *   triggerHaptic(onHaptics, request, trigger) — thin forwarding\n *     helper for event-driven variants (`active:haptic-*`, `focus:...`,\n *     `hover:...`). The transformer emits an inline arrow that calls\n *     this from `onPressIn` / `onFocus` / etc.\n *\n * Both emit a one-shot dev-mode warning when `onHaptics` is missing —\n * so developers get a clear \"you forgot to wire <SchemeProvider\n * onHaptics=...>\" signal instead of silently dropping the haptic.\n */\n\nimport { useEffect } from 'react'\nimport type { HapticRequest, HapticTrigger, OnHaptics } from '../core/parser/haptics'\nimport { useRnwind } from './components/rnwind-provider'\n\n/**\n * Module-scope set tracking haptic trigger strings we've already\n * warned about. Prevents the \"missing onHaptics\" warning from\n * spamming the console when the same class appears on many elements.\n */\nconst WARNED_MISSING_HAPTICS = new Set<string>()\n\n/**\n * Render a `HapticRequest` as a short descriptive tag for log lines.\n * @param request Haptic request.\n * @returns `impact/Light`, `notification/Success`, or `selection`.\n */\nfunction hapticTag(request: HapticRequest): string {\n  if (request.kind === 'impact') return `impact/${request.style}`\n  if (request.kind === 'notification') return `notification/${request.type}`\n  return 'selection'\n}\n\n/**\n * Warn once per haptic trigger kind when a `haptic-*` atom tries to\n * dispatch without an `onHaptics` provider. Dev-mode only — `__DEV__`\n * is a Metro / Expo / RN global that compiles to `false` in release\n * bundles, so no warn code ships to production.\n * @param request The haptic request that had no provider.\n * @param trigger The lifecycle trigger that tried to fire.\n */\nfunction warnMissingOnHaptics(request: HapticRequest, trigger: HapticTrigger): void {\n  // `__DEV__` is a RN / Metro global — `false` in release, strips the\n  // branch entirely. Guarded in case we're evaluated outside of Metro\n  // (tests, node scripts) where the global isn't defined.\n  const isDevelopment = typeof __DEV__ === 'undefined' || __DEV__\n  if (!isDevelopment) return\n  const tag = hapticTag(request)\n  const key = `${tag}@${trigger}`\n  if (WARNED_MISSING_HAPTICS.has(key)) return\n  WARNED_MISSING_HAPTICS.add(key)\n  // eslint-disable-next-line no-console\n  console.warn(\n    `rnwind: a haptic utility fired (${tag}, trigger=${trigger}) but no onHaptics callback is wired on <SchemeProvider>. ` +\n      `Pass \\`onHaptics\\` on the provider to forward this to expo-haptics (or any library of your choice).`,\n  )\n}\n\n/**\n * Test-only hook — clears the warned-haptics set so successive test\n * runs don't silently swallow their own warnings.\n */\nfunction __resetHapticWarnings(): void {\n  WARNED_MISSING_HAPTICS.clear()\n}\n\n/**\n * Invoke every request in `requests` on mount (once per component\n * mount), using the `onHaptics` dispatcher from the nearest\n * `<SchemeProvider>`. Missing-provider dev warnings fire via\n * {@link warnMissingOnHaptics}.\n *\n * Uses `useEffect(..., [])` — the requests array is identity-stable\n * (hoisted at module scope by the transformer), so re-firing on\n * re-renders isn't a concern.\n * @param requests Hoisted request list for this component.\n */\nfunction useMountHaptic(requests: readonly HapticRequest[]): void {\n  const { onHaptics } = useRnwind()\n   \n  useEffect(() => {\n    for (const request of requests) {\n      if (onHaptics) onHaptics(request, 'mount')\n      else warnMissingOnHaptics(request, 'mount')\n    }\n    // requests is a hoisted stable reference — depending on onHaptics\n    // identity keeps the effect fresh if the provider remounts with a\n    // different dispatcher, while the hoisted const prevents a remount\n    // from an inline `onHaptics={(r) => ...}`.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [onHaptics])\n}\n\n/**\n * Fire one haptic request through the provider dispatcher. Emits the\n * missing-provider dev warning when no dispatcher is wired. Designed\n * for the inline arrows the transformer synthesises:\n *\n *   onPressIn={(e) => { triggerHaptic(_h, _HR_xxx, 'pressIn'); user?.(e) }}\n * @param onHaptics Provider dispatcher (may be undefined).\n * @param request Pre-hoisted request object.\n * @param trigger Lifecycle trigger.\n */\nfunction triggerHaptic(onHaptics: OnHaptics | undefined, request: HapticRequest, trigger: HapticTrigger): void {\n  if (onHaptics) {\n    onHaptics(request, trigger)\n    return\n  }\n  warnMissingOnHaptics(request, trigger)\n}\n\nexport { useMountHaptic, triggerHaptic, __resetHapticWarnings }\n"],"names":["useRnwind","useEffect"],"mappings":";;;;;AAAA;;;;;;;;;;;;;;;;;AAiBG;AAMH;;;;AAIG;AACH,MAAM,sBAAsB,GAAG,IAAI,GAAG,EAAU;AAEhD;;;;AAIG;AACH,SAAS,SAAS,CAAC,OAAsB,EAAA;AACvC,IAAA,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ;AAAE,QAAA,OAAO,CAAA,OAAA,EAAU,OAAO,CAAC,KAAK,EAAE;AAC/D,IAAA,IAAI,OAAO,CAAC,IAAI,KAAK,cAAc;AAAE,QAAA,OAAO,CAAA,aAAA,EAAgB,OAAO,CAAC,IAAI,EAAE;AAC1E,IAAA,OAAO,WAAW;AACpB;AAEA;;;;;;;AAOG;AACH,SAAS,oBAAoB,CAAC,OAAsB,EAAE,OAAsB,EAAA;;;;IAI1E,MAAM,aAAa,GAAG,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO;AAC/D,IAAA,IAAI,CAAC,aAAa;QAAE;AACpB,IAAA,MAAM,GAAG,GAAG,SAAS,CAAC,OAAO,CAAC;AAC9B,IAAA,MAAM,GAAG,GAAG,CAAA,EAAG,GAAG,CAAA,CAAA,EAAI,OAAO,EAAE;AAC/B,IAAA,IAAI,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE;AACrC,IAAA,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC;;AAE/B,IAAA,OAAO,CAAC,IAAI,CACV,mCAAmC,GAAG,CAAA,UAAA,EAAa,OAAO,CAAA,0DAAA,CAA4D;AACpH,QAAA,CAAA,mGAAA,CAAqG,CACxG;AACH;AAUA;;;;;;;;;;AAUG;AACH,SAAS,cAAc,CAAC,QAAkC,EAAA;AACxD,IAAA,MAAM,EAAE,SAAS,EAAE,GAAGA,wBAAS,EAAE;IAEjCC,eAAS,CAAC,MAAK;AACb,QAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;AAC9B,YAAA,IAAI,SAAS;AAAE,gBAAA,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;;AACrC,gBAAA,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC;QAC7C;;;;;;AAMF,IAAA,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AACjB;AAEA;;;;;;;;;AASG;AACH,SAAS,aAAa,CAAC,SAAgC,EAAE,OAAsB,EAAE,OAAsB,EAAA;IACrG,IAAI,SAAS,EAAE;AACb,QAAA,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;QAC3B;IACF;AACA,IAAA,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC;AACxC;;;;;"}

package/lib/cjs/runtime/haptics.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Runtime helpers the transformer injects for haptic utilities.
+ *
+ * Two entry points:
+ *
+ *   useMountHaptic(requests) — fires each request on mount via
+ *     `useEffect(() => { ... }, [])`. Used by the transformer for bare
+ *     `haptic-*` atoms (no variant prefix).
+ *
+ *   triggerHaptic(onHaptics, request, trigger) — thin forwarding
+ *     helper for event-driven variants (`active:haptic-*`, `focus:...`,
+ *     `hover:...`). The transformer emits an inline arrow that calls
+ *     this from `onPressIn` / `onFocus` / etc.
+ *
+ * Both emit a one-shot dev-mode warning when `onHaptics` is missing —
+ * so developers get a clear "you forgot to wire <SchemeProvider
+ * onHaptics=...>" signal instead of silently dropping the haptic.
+ */
+import type { HapticRequest, HapticTrigger, OnHaptics } from '../core/parser/haptics';
+/**
+ * Test-only hook — clears the warned-haptics set so successive test
+ * runs don't silently swallow their own warnings.
+ */
+declare function __resetHapticWarnings(): void;
+/**
+ * Invoke every request in `requests` on mount (once per component
+ * mount), using the `onHaptics` dispatcher from the nearest
+ * `<SchemeProvider>`. Missing-provider dev warnings fire via
+ * {@link warnMissingOnHaptics}.
+ *
+ * Uses `useEffect(..., [])` — the requests array is identity-stable
+ * (hoisted at module scope by the transformer), so re-firing on
+ * re-renders isn't a concern.
+ * @param requests Hoisted request list for this component.
+ */
+declare function useMountHaptic(requests: readonly HapticRequest[]): void;
+/**
+ * Fire one haptic request through the provider dispatcher. Emits the
+ * missing-provider dev warning when no dispatcher is wired. Designed
+ * for the inline arrows the transformer synthesises:
+ *
+ *   onPressIn={(e) => { triggerHaptic(_h, _HR_xxx, 'pressIn'); user?.(e) }}
+ * @param onHaptics Provider dispatcher (may be undefined).
+ * @param request Pre-hoisted request object.
+ * @param trigger Lifecycle trigger.
+ */
+declare function triggerHaptic(onHaptics: OnHaptics | undefined, request: HapticRequest, trigger: HapticTrigger): void;
+export { useMountHaptic, triggerHaptic, __resetHapticWarnings };

package/lib/cjs/runtime/hooks/use-css.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var rnwindProvider = require('../components/rnwind-provider.cjs');
+var lookupCss = require('../lookup-css.cjs');
+
+/**
+ * Convenience hook: `useRnwind()` + `lookupCss()` rolled into one. Use
+ * inside any component that wants the resolved style array without
+ * threading the rnwind context manually. JSX-heavy components should
+ * still call `useRnwind()` once and pass it to `lookupCss(...)` per
+ * element so React only does a single context read per render.
+ * @param className Raw className string or transformer-hoisted atom-name array.
+ * @param userStyle Optional caller-supplied style appended last.
+ * @returns Frozen style array for React Native's `style` prop.
+ */
+function useCss(className, userStyle) {
+    return lookupCss.lookupCss(className, rnwindProvider.useRnwind(), userStyle);
+}
+
+exports.useCss = useCss;
+//# sourceMappingURL=use-css.cjs.map

package/lib/cjs/runtime/hooks/use-css.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-css.cjs","sources":["../../../../../src/runtime/hooks/use-css.ts"],"sourcesContent":["import { useRnwind } from '../components/rnwind-provider'\nimport { lookupCss } from '../lookup-css'\n\n/**\n * Convenience hook: `useRnwind()` + `lookupCss()` rolled into one. Use\n * inside any component that wants the resolved style array without\n * threading the rnwind context manually. JSX-heavy components should\n * still call `useRnwind()` once and pass it to `lookupCss(...)` per\n * element so React only does a single context read per render.\n * @param className Raw className string or transformer-hoisted atom-name array.\n * @param userStyle Optional caller-supplied style appended last.\n * @returns Frozen style array for React Native's `style` prop.\n */\nexport function useCss(className?: string | readonly string[] | null, userStyle?: unknown): readonly unknown[] {\n  return lookupCss(className, useRnwind(), userStyle)\n}\n"],"names":["lookupCss","useRnwind"],"mappings":";;;;;AAGA;;;;;;;;;AASG;AACG,SAAU,MAAM,CAAC,SAA6C,EAAE,SAAmB,EAAA;IACvF,OAAOA,mBAAS,CAAC,SAAS,EAAEC,wBAAS,EAAE,EAAE,SAAS,CAAC;AACrD;;;;"}

package/lib/cjs/runtime/hooks/use-css.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convenience hook: `useRnwind()` + `lookupCss()` rolled into one. Use
+ * inside any component that wants the resolved style array without
+ * threading the rnwind context manually. JSX-heavy components should
+ * still call `useRnwind()` once and pass it to `lookupCss(...)` per
+ * element so React only does a single context read per render.
+ * @param className Raw className string or transformer-hoisted atom-name array.
+ * @param userStyle Optional caller-supplied style appended last.
+ * @returns Frozen style array for React Native's `style` prop.
+ */
+export declare function useCss(className?: string | readonly string[] | null, userStyle?: unknown): readonly unknown[];

package/lib/cjs/runtime/hooks/use-interact.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var React = require('react');
+
+/**
+ * Idle state reference reused across every non-interactive render —
+ * when neither `active` nor `focus` is true, every call site returns
+ * the exact same object. That's the ~99 % path for a typical list row,
+ * so sharing the ref is a legitimate allocation elimination.
+ */
+const IDLE_STATE = { active: false, focus: false };
+/**
+ * React hook driving `active:` / `focus:` variants at runtime. The
+ * transformer injects exactly one call per JSX element that uses an
+ * interactive classname, caching the hook's result into a component-
+ * local `_i` binding so every `lookupCss(…, _i.state)` site shares the
+ * same snapshot per render.
+ *
+ * React Native's `Pressable` fires `onPressIn` / `onPressOut` on touch
+ * down / release — the touch-device analogue of CSS `:active`. Text
+ * fields use `onFocus` / `onBlur`. Both pairs drive `useState` Booleans;
+ * unused handlers on elements that don't emit the corresponding event
+ * are harmless no-ops.
+ *
+ * Result stability: both `state` and the returned wrapper object stay
+ * reference-equal across renders unless `active` / `focus` actually
+ * flip. Downstream `React.memo` + `lookupCss` caches hit on equal refs.
+ * @returns Stable state + handler bundle.
+ */
+function useInteract() {
+    const [active, setActive] = React.useState(false);
+    const [focus, setFocus] = React.useState(false);
+    const onPressIn = React.useCallback(() => setActive(true), []);
+    const onPressOut = React.useCallback(() => setActive(false), []);
+    const onFocus = React.useCallback(() => setFocus(true), []);
+    const onBlur = React.useCallback(() => setFocus(false), []);
+    const state = React.useMemo(() => {
+        if (!active && !focus)
+            return IDLE_STATE;
+        return { active, focus };
+    }, [active, focus]);
+    return React.useMemo(() => ({ state, onPressIn, onPressOut, onFocus, onBlur }), [state, onPressIn, onPressOut, onFocus, onBlur]);
+}
+
+exports.useInteract = useInteract;
+//# sourceMappingURL=use-interact.cjs.map

package/lib/cjs/runtime/hooks/use-interact.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interact.cjs","sources":["../../../../../src/runtime/hooks/use-interact.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from 'react'\nimport type { GestureResponderEvent, NativeSyntheticEvent, TargetedEvent } from 'react-native'\nimport type { InteractState } from '../lookup-css'\n\n/**\n * Idle state reference reused across every non-interactive render —\n * when neither `active` nor `focus` is true, every call site returns\n * the exact same object. That's the ~99 % path for a typical list row,\n * so sharing the ref is a legitimate allocation elimination.\n */\nconst IDLE_STATE: InteractState = { active: false, focus: false }\n\n/**\n * Live interact-state snapshot plus the press/focus handlers the\n * transformer wires onto the JSX opening element. The state object is\n * referentially stable across renders when the underlying `active` /\n * `focus` flags don't change, which keeps `lookupCss` cache hits\n * aligned with React's render cadence (same state ref → same\n * resolved-array cache key → same reference back, no React diff\n * triggered).\n */\nexport interface UseInteractResult {\n  /** Current interact flags — forwarded as the 4th arg to `lookupCss`. */\n  state: InteractState\n  /** Wired by the transformer onto `<Pressable onPressIn={…}>` etc. */\n  onPressIn: (event: GestureResponderEvent) => void\n  /** Wired by the transformer onto `<Pressable onPressOut={…}>` etc. */\n  onPressOut: (event: GestureResponderEvent) => void\n  /** Wired by the transformer onto `<TextInput onFocus={…}>` etc. */\n  onFocus: (event: NativeSyntheticEvent<TargetedEvent>) => void\n  /** Wired by the transformer onto `<TextInput onBlur={…}>` etc. */\n  onBlur: (event: NativeSyntheticEvent<TargetedEvent>) => void\n}\n\n/**\n * React hook driving `active:` / `focus:` variants at runtime. The\n * transformer injects exactly one call per JSX element that uses an\n * interactive classname, caching the hook's result into a component-\n * local `_i` binding so every `lookupCss(…, _i.state)` site shares the\n * same snapshot per render.\n *\n * React Native's `Pressable` fires `onPressIn` / `onPressOut` on touch\n * down / release — the touch-device analogue of CSS `:active`. Text\n * fields use `onFocus` / `onBlur`. Both pairs drive `useState` Booleans;\n * unused handlers on elements that don't emit the corresponding event\n * are harmless no-ops.\n *\n * Result stability: both `state` and the returned wrapper object stay\n * reference-equal across renders unless `active` / `focus` actually\n * flip. Downstream `React.memo` + `lookupCss` caches hit on equal refs.\n * @returns Stable state + handler bundle.\n */\nexport function useInteract(): UseInteractResult {\n  const [active, setActive] = useState(false)\n  const [focus, setFocus] = useState(false)\n  const onPressIn = useCallback(() => setActive(true), [])\n  const onPressOut = useCallback(() => setActive(false), [])\n  const onFocus = useCallback(() => setFocus(true), [])\n  const onBlur = useCallback(() => setFocus(false), [])\n  const state = useMemo<InteractState>(() => {\n    if (!active && !focus) return IDLE_STATE\n    return { active, focus }\n  }, [active, focus])\n  return useMemo(() => ({ state, onPressIn, onPressOut, onFocus, onBlur }), [state, onPressIn, onPressOut, onFocus, onBlur])\n}\n"],"names":["useState","useCallback","useMemo"],"mappings":";;;;AAIA;;;;;AAKG;AACH,MAAM,UAAU,GAAkB,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE;AAwBjE;;;;;;;;;;;;;;;;;AAiBG;SACa,WAAW,GAAA;IACzB,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAGA,cAAQ,CAAC,KAAK,CAAC;IAC3C,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAGA,cAAQ,CAAC,KAAK,CAAC;AACzC,IAAA,MAAM,SAAS,GAAGC,iBAAW,CAAC,MAAM,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;AACxD,IAAA,MAAM,UAAU,GAAGA,iBAAW,CAAC,MAAM,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;AAC1D,IAAA,MAAM,OAAO,GAAGA,iBAAW,CAAC,MAAM,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;AACrD,IAAA,MAAM,MAAM,GAAGA,iBAAW,CAAC,MAAM,QAAQ,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;AACrD,IAAA,MAAM,KAAK,GAAGC,aAAO,CAAgB,MAAK;AACxC,QAAA,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK;AAAE,YAAA,OAAO,UAAU;AACxC,QAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE;AAC1B,IAAA,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACnB,IAAA,OAAOA,aAAO,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAC5H;;;;"}

package/lib/cjs/runtime/hooks/use-interact.d.ts

@@ -0,0 +1,42 @@
+import type { GestureResponderEvent, NativeSyntheticEvent, TargetedEvent } from 'react-native';
+import type { InteractState } from '../lookup-css';
+/**
+ * Live interact-state snapshot plus the press/focus handlers the
+ * transformer wires onto the JSX opening element. The state object is
+ * referentially stable across renders when the underlying `active` /
+ * `focus` flags don't change, which keeps `lookupCss` cache hits
+ * aligned with React's render cadence (same state ref → same
+ * resolved-array cache key → same reference back, no React diff
+ * triggered).
+ */
+export interface UseInteractResult {
+    /** Current interact flags — forwarded as the 4th arg to `lookupCss`. */
+    state: InteractState;
+    /** Wired by the transformer onto `<Pressable onPressIn={…}>` etc. */
+    onPressIn: (event: GestureResponderEvent) => void;
+    /** Wired by the transformer onto `<Pressable onPressOut={…}>` etc. */
+    onPressOut: (event: GestureResponderEvent) => void;
+    /** Wired by the transformer onto `<TextInput onFocus={…}>` etc. */
+    onFocus: (event: NativeSyntheticEvent<TargetedEvent>) => void;
+    /** Wired by the transformer onto `<TextInput onBlur={…}>` etc. */
+    onBlur: (event: NativeSyntheticEvent<TargetedEvent>) => void;
+}
+/**
+ * React hook driving `active:` / `focus:` variants at runtime. The
+ * transformer injects exactly one call per JSX element that uses an
+ * interactive classname, caching the hook's result into a component-
+ * local `_i` binding so every `lookupCss(…, _i.state)` site shares the
+ * same snapshot per render.
+ *
+ * React Native's `Pressable` fires `onPressIn` / `onPressOut` on touch
+ * down / release — the touch-device analogue of CSS `:active`. Text
+ * fields use `onFocus` / `onBlur`. Both pairs drive `useState` Booleans;
+ * unused handlers on elements that don't emit the corresponding event
+ * are harmless no-ops.
+ *
+ * Result stability: both `state` and the returned wrapper object stay
+ * reference-equal across renders unless `active` / `focus` actually
+ * flip. Downstream `React.memo` + `lookupCss` caches hit on equal refs.
+ * @returns Stable state + handler bundle.
+ */
+export declare function useInteract(): UseInteractResult;

package/lib/cjs/runtime/hooks/use-scheme.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+var rnwindProvider = require('../components/rnwind-provider.cjs');
+
+/**
+ * Synthetic scheme name applied when tokens aren't declared under any
+ * `@variant` block — the "no active variant" fallback every theme table
+ * inherits from.
+ */
+const BASE_SCHEME = 'base';
+/**
+ * Access the resolved theme table for the active scheme.
+ *
+ * Tokens declared outside any `@variant` block live in the `base` table and
+ * should apply everywhere — just like the CSS cascade treats `:root` as a
+ * default for every ancestor-scoped override. We merge `base` under the
+ * active scheme so a scheme that doesn't declare a token still sees the
+ * base default, while the scheme's own entries win on overlap.
+ * @returns Token table for the active scheme.
+ */
+function useTheme() {
+    const { scheme, tables } = rnwindProvider.useRnwind();
+    const base = tables[BASE_SCHEME] ?? {};
+    const schemeTable = tables[scheme];
+    if (!schemeTable)
+        return base;
+    // Fast path: nothing to merge when the scheme table is empty.
+    if (Object.keys(schemeTable).length === 0)
+        return base;
+    return { ...base, ...schemeTable };
+}
+/**
+ * Read a raw CSS custom property's value for the active scheme. Accepts
+ * either `--foo` or the bare `foo` form for convenience.
+ * @param cssVariable CSS custom property name (with or without the leading `--`).
+ * @returns The resolved value, or undefined when the token is missing.
+ */
+function useToken(cssVariable) {
+    const table = useTheme();
+    const name = cssVariable.startsWith('--') ? cssVariable : `--${cssVariable}`;
+    return table[name];
+}
+/**
+ * Read a color token by shorthand name — `useColor('primary')` resolves
+ * `--color-primary` for the active scheme.
+ * @param name Token suffix after `--color-`.
+ * @returns Resolved color string, or undefined when the token is missing
+ *   or its value isn't a string.
+ */
+function useColor(name) {
+    const value = useToken(`--color-${name}`);
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Read a spacing token by shorthand name — `useSize('4')` resolves
+ * `--spacing-4` for the active scheme.
+ * @param name Token suffix after `--spacing-`.
+ * @returns Resolved spacing value, or undefined when the token is missing.
+ */
+function useSize(name) {
+    return useToken(`--spacing-${name}`);
+}
+
+exports.useColor = useColor;
+exports.useSize = useSize;
+exports.useTheme = useTheme;
+exports.useToken = useToken;
+//# sourceMappingURL=use-scheme.cjs.map