@sigx/lynx-navigation 0.1.3 → 0.4.0

package/README.md

@@ -98,7 +98,95 @@ and every other API gets typed.
 ### `<Stack>`
 
 Renders the topmost stack entry plus the entry beneath it during
-transitions. No props — driven entirely by the navigator state.
+transitions. By default it binds to the enclosing navigator (the root one
+under `<NavigationRoot>`).
+
+Pass `initialRoute` to make `<Stack>` create its **own** nested navigator —
+this is how per-tab stacks work. See [Per-tab nested stacks](#per-tab-nested-stacks).
+
+```tsx
+<Stack initialRoute="tripsHome" />
+<Stack initialRoute="profile" initialParams={{ id: 'me' }} />
+```
+
+### Per-tab nested stacks
+
+Drop a `<Stack initialRoute=…>` inside each `<Tabs.Screen>` to give every
+tab its own back-stack. Card-presentation pushes stay inside the tab;
+modal / fullScreen / transparent-modal pushes **escalate** to the root
+navigator so they overlay the entire tabs UI (TabBar included).
+
+```tsx
+<NavigationRoot routes={routes} initialRoute="root">
+    <Header />
+    <Stack />        {/* root navigator — renders the `root` entry below */}
+</NavigationRoot>
+
+// `root` route renders this:
+<Tabs initialTab="trips">
+    <Tabs.Screen name="trips" label="Trips">
+        <Stack initialRoute="tripsHome" />
+    </Tabs.Screen>
+    <Tabs.Screen name="map" label="Map">
+        <Stack initialRoute="mapHome" />
+    </Tabs.Screen>
+    <TabBar />
+</Tabs>
+```
+
+Inside a tab body, `useNav()` resolves to the **innermost** navigator:
+
+- `nav.push('tripDetail', { tripId })` — `tripDetail` is a card route →
+  pushed onto the trips tab's stack, TabBar stays visible.
+- `nav.push('newTrip')` — `newTrip` is `presentation: 'modal'` → walks up
+  `nav.parent` to root and pushes there, overlays the whole tabs UI.
+- `nav.replace(...)` is **strictly local** and never escalates (asymmetric
+  with `push` by design — keeps the root stack stable).
+- Hardware/edge back pops the focused inner nav first; only falls through
+  to root once the inner stack is empty.
+- `useIsFocused()` is `true` only when the screen is the top of its own
+  nav **and** every ancestor is focused (parent's current entry matches +
+  enclosing tab is active).
+
+**Modal preservation.** When a `modal` / `fullScreen` /
+`transparent-modal` push goes onto the root navigator (via escalation
+from a per-tab stack), `<Stack>` keeps the underneath entry mounted
+behind the overlay. Per-tab stack state, scroll positions, and in-flight
+inputs all survive the modal lifecycle. Card pushes still replace the
+underneath in the base layer — the user's mental model is "back
+recreates the previous screen from history".
+
+**Limitations (current slice)**:
+
+- One global route registry — there's no per-tab whitelist yet. Deep-link
+  routing always pushes against the innermost nav of the caller site
+  (modal routes still escalate). A future slice may add `<Stack routes={…}>`.
+- `useNavSerializer` snapshots one nav only — nested-tab stack state isn't
+  persisted across reload yet.
+
+### Per-stack header chrome
+
+`<Stack>` accepts a default slot — its children render *inside* the
+stack's nav scope, above the active screen. That's how to give a
+nested per-tab stack its own header, since the root-level `<Header />`
+only tracks the root navigator:
+
+```tsx
+<Tabs.Screen name="trips" label="Trips">
+    <Stack initialRoute="tripsHome">
+        <Header />   {/* useNav() here resolves to the per-tab nav */}
+    </Stack>
+</Tabs.Screen>
+```
+
+Without this, a `<Header />` placed as a sibling of `<Stack>` would
+resolve `useNav()` to the *enclosing* nav and never react to pushes
+inside the nested stack — the back button + title wouldn't update on
+`nav.push('tripDetail', ...)`.
+
+For a daisy-themed bar (height, padding, centred title, separator),
+use `<NavHeader />` from `@sigx/lynx-daisyui` — same slot position,
+same `useScreenChrome()` data source.
 
 ### `<Screen>`
 
@@ -126,13 +214,61 @@ const Profile = component(() => () => (
 All sub-slots are optional. Anything not declared falls back to the
 navigator's default chrome.
 
+**Placement — `<Screen>` is a child component, return it from
+render.** `<Screen>` and its slot-filler siblings (`<Screen.Header>`,
+`<Screen.HeaderRight>`, etc.) each call `useScreenRegistry()` from
+their *own* setup, which means they have to actually mount inside
+your screen's `<EntryScope>` to find the registry — and that only
+happens when JSX returned from your render function is reconciled
+into the tree. Constructing `<Screen ... />` JSX inside setup without
+returning it doesn't mount anything:
+
+```tsx
+// ✗ Won't take effect — the JSX is created but never rendered.
+const Profile = component(() => {
+    <Screen title="Profile" />;
+    return () => <view>profile body</view>;
+});
+
+// ✓ Returned from render — gets mounted, registers its options.
+const Profile = component(() => {
+    return () => (
+        <Screen title="Profile">
+            <view>profile body</view>
+        </Screen>
+    );
+});
+```
+
+When `<Screen>` *does* mount outside of any `<EntryScope>` — typically
+because the consumer placed it at the app root instead of inside a
+route component — it throws:
+
+> `[lynx-navigation] No screen registry in scope. `<Screen>` (and
+> `<Screen.Header>`, etc.) must be used inside a route component
+> rendered by `<Stack>`.`
+
+If you need to write options *imperatively* at setup time (e.g. to
+react to a hook result before the first render), reach for
+`useScreenOptions(...)` — it calls `useScreenRegistry()` directly
+from your own setup, where the EntryScope's registry is already
+visible.
+
 ### `<Header>`
 
-Default navigator header. Reads the focused entry's `<Screen.Header>`
-slot if set, otherwise renders `headerLeft | title | headerRight` with a
-back button as the default `headerLeft` when `nav.canGoBack` is true.
-Pulls `title` / `headerShown` / `gestureEnabled` from the focused
-screen's `useScreenOptions(...)` registration.
+**Headless** default navigator header — bare `<view>`/`<text>` nodes,
+no flex direction, no padding, no theme. Reads the focused entry's
+`<Screen.Header>` slot if set, otherwise renders
+`headerLeft | title | headerRight` with a back button as the default
+`headerLeft` when `nav.canGoBack` is true. Pulls `title` /
+`headerShown` / `gestureEnabled` from the focused screen's
+`useScreenOptions(...)` registration (or declarative `<Screen title=…>`).
+
+For a daisy-themed bar with sensible defaults (surface colour,
+separator, fixed ~48dp height, centred title), use `<NavHeader />`
+from `@sigx/lynx-daisyui` — same data source via `useScreenChrome()`.
+Custom designs can build their own component on top of
+`useScreenChrome()` without touching internals.
 
 ```tsx
 <NavigationRoot routes={routes} initialRoute="home">
@@ -143,7 +279,10 @@ screen's `useScreenOptions(...)` registration.
 
 ### `<Tabs>` + `<Tabs.Screen>` + `<TabBar>`
 
-Persistent tab navigator. Each tab keeps its own stack across switches.
+Persistent tab navigator. Each tab body stays mounted (hidden via
+`display: none`) so switching tabs preserves state. Drop a `<Stack
+initialRoute=…>` inside a `<Tabs.Screen>` to give that tab its own
+back-stack — see [Per-tab nested stacks](#per-tab-nested-stacks).
 
 ```tsx
 <Tabs initialTab="home">
@@ -250,6 +389,49 @@ const Profile = component(() => {
 });
 ```
 
+Equivalent declarative form via `<Screen>`:
+
+```tsx
+<Screen title={() => `User ${id}`} />
+```
+
+`<Screen>` only patches keys you actually pass — omitting `title`
+won't clear a title set elsewhere on the same entry. Safe to use a
+bare `<Screen>` purely to host `<Screen.HeaderRight>` slots without
+worrying about wiping a sibling `useScreenOptions(...)` write.
+
+### `useScreenChrome()`
+
+Reactive read of the focused screen's options + slot fills, plus
+navigation helpers a header would need (`canGoBack`, `pop`). The
+public foundation for building custom header components without
+touching internal modules — `<NavHeader />` in `@sigx/lynx-daisyui` is
+built on this.
+
+```tsx
+import { useScreenChrome } from '@sigx/lynx-navigation';
+
+const MyHeader = component(() => {
+    const chrome = useScreenChrome();
+    return () => {
+        if (!chrome.headerShown) return null;
+        return (
+            <view class="my-header">
+                {chrome.canGoBack
+                    ? <view bindtap={chrome.pop}><text>‹ Back</text></view>
+                    : null}
+                <text>{chrome.title}</text>
+                {chrome.headerRight?.()}
+            </view>
+        );
+    };
+});
+```
+
+Every property is a getter — reading it inside a render or `computed`
+subscribes to the underlying signal, so the consumer re-renders when
+title / slots change.
+
 ### `useLinkingNav(options?)`
 
 Bridges `@sigx/lynx-linking` URL events into the navigator. Call once

package/dist/components/EntryScope.d.ts

@@ -1,5 +1,5 @@
 import { type Define } from '@sigx/lynx';
-import type { StackEntry } from '../types.js';
+import type { StackEntry } from '../types';
 type EntryScopeProps = Define.Prop<'entry', StackEntry, true> & Define.Slot<'default'>;
 /**
  * Provider wrapper for a single screen mount.

package/dist/components/EntryScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntryScope.d.ts","sourceRoot":"","sources":["../../src/components/EntryScope.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAyC,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAGhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,KAAK,eAAe,GACd,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,GACtC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU;;EAUrB,CAAC"}
+{"version":3,"file":"EntryScope.d.ts","sourceRoot":"","sources":["../../src/components/EntryScope.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAyC,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAQhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,KAAK,eAAe,GACd,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,GACtC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU;;EAgBrB,CAAC"}

package/dist/components/Layer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `<Layer>` — one row in `<Stack>`'s layered render. Absolutely-
+ * positioned host view that fills the Stack's relative wrapper, with
+ * an optional MT-bound `translateX` / `translateY` animation driven
+ * by a `SharedValue<number>` from the navigator's transition state.
+ *
+ * `<Stack>` emits one `<Layer>` per entry returned by
+ * `computeLayers(...)`. Layer.key in the parent is
+ * `layer-${entry.key}-${animationVariant(animation)}` so that:
+ *
+ *  - The same entry under the same animation state is preserved across
+ *    renders (modal underneath stays mounted through the modal
+ *    lifecycle; per-tab Stack state survives).
+ *  - An entry transitioning between animated and static (e.g. a card
+ *    top after its push transition completes) remounts so the
+ *    `useAnimatedStyle` binding can be rebound — the underlying
+ *    `useAnimatedStyle` is set-once at setup and can't switch its
+ *    mapper at runtime.
+ *
+ * Layouts:
+ *  - Host view is `position: absolute; top/right/bottom/left: 0;
+ *    display: flex; flexDirection: column` so descendants that
+ *    flex-fill (SafeAreaView, daisyui screens) get a sized parent.
+ *  - No background. Screens own their own surface colour (typically
+ *    via a daisy `bg-base-*` class on the screen body).
+ */
+import { type ComponentFactory, type Define } from '@sigx/lynx';
+import type { LayerAnimation } from '../internal/layer-plan';
+import type { RouteMap, StackEntry } from '../types';
+export type LayerProps = Define.Prop<'entry', StackEntry, true> & Define.Prop<'routes', RouteMap, true>
+/** When set, the host view animates per the transform spec. */
+ & Define.Prop<'animation', LayerAnimation | null, false>;
+export declare const Layer: ComponentFactory<LayerProps, void, {}>;
+//# sourceMappingURL=Layer.d.ts.map

package/dist/components/Layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../src/components/Layer.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAIH,KAAK,gBAAgB,EACrB,KAAK,MAAM,EAEd,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGrD,MAAM,MAAM,UAAU,GAChB,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,GACtC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC;AACvC,+DAA+D;GAC7D,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC;AAE7D,eAAO,MAAM,KAAK,wCAkDhB,CAAC"}

package/dist/components/Link.d.ts

@@ -1,5 +1,5 @@
-import type { RouteId, RouteParams, RouteSearch } from '../register.js';
-import type { RoutesWithParams } from '../hooks/use-nav.js';
+import type { RouteId, RouteParams, RouteSearch } from '../register';
+import type { RoutesWithParams } from '../hooks/use-nav';
 /**
  * Per-route conditional props for `<Link>`.
  *

package/dist/components/Link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../src/components/Link.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,KAAK,gBAAgB,GAAG;KACnB,CAAC,IAAI,OAAO,GAAG,CAAC,SAAS,gBAAgB,GACpC;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,GAC1D;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE;CAC/D,CAAC,OAAO,CAAC,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG;IACvC,8DAA8D;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAwDF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,EAA0B,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC"}
+{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../src/components/Link.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;;;;;;;;;;;GAaG;AACH,KAAK,gBAAgB,GAAG;KACnB,CAAC,IAAI,OAAO,GAAG,CAAC,SAAS,gBAAgB,GACpC;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,GAC1D;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE;CAC/D,CAAC,OAAO,CAAC,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG;IACvC,8DAA8D;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAwDF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,EAA0B,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC"}

package/dist/components/NavigationRoot.d.ts

@@ -1,6 +1,6 @@
 import { type Define } from '@sigx/lynx';
-import type { RouteId } from '../register.js';
-import type { RouteMap } from '../types.js';
+import type { RouteId } from '../register';
+import type { RouteMap } from '../types';
 type NavigationRootProps = Define.Prop<'routes', RouteMap, true> & Define.Prop<'initialRoute', RouteId> & Define.Prop<'initialParams', Record<string, unknown>> & Define.Prop<'initialSearch', Record<string, unknown>>
 /**
  * Enable slide-from-right transitions on push/pop. Defaults to true.

package/dist/components/NavigationRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NavigationRoot.d.ts","sourceRoot":"","sources":["../../src/components/NavigationRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAInF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAgB,QAAQ,EAAc,MAAM,aAAa,CAAC;AAGtE,KAAK,mBAAmB,GAClB,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,GACrC,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GACpC,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACrD,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD;;;;GAIG;GACD,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;AAClC;;;;GAIG;GACD,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,GACxC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc;;EAiDzB,CAAC"}
+{"version":3,"file":"NavigationRoot.d.ts","sourceRoot":"","sources":["../../src/components/NavigationRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAInF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAgB,QAAQ,EAAc,MAAM,UAAU,CAAC;AAGnE,KAAK,mBAAmB,GAClB,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,GACrC,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GACpC,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACrD,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD;;;;GAIG;GACD,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;AAClC;;;;GAIG;GACD,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,GACxC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc;;EAiDzB,CAAC"}

package/dist/components/Screen.d.ts

@@ -50,9 +50,9 @@ type TabBarItemProps = Define.Slot<'default'>;
  * call site shown in the file header.
  */
 export declare const Screen: ((props: {
-    title?: string | (() => string) | undefined;
-    headerShown?: boolean | undefined;
     gestureEnabled?: boolean | undefined;
+    headerShown?: boolean | undefined;
+    title?: string | (() => string) | undefined;
 } & {} & {
     slots?: Partial<{
         default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
@@ -62,18 +62,18 @@ export declare const Screen: ((props: {
     children?: any;
 }) => import("@sigx/runtime-core").JSXElement) & {
     __setup: import("@sigx/runtime-core").SetupFn<{
-        title?: string | (() => string) | undefined;
-        headerShown?: boolean | undefined;
         gestureEnabled?: boolean | undefined;
+        headerShown?: boolean | undefined;
+        title?: string | (() => string) | undefined;
     }, ScreenProps, void, {
         default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
     }>;
     __name?: string;
     __islandId?: string;
     __props: {
-        title?: string | (() => string) | undefined;
-        headerShown?: boolean | undefined;
         gestureEnabled?: boolean | undefined;
+        headerShown?: boolean | undefined;
+        title?: string | (() => string) | undefined;
     };
     __events: ScreenProps;
     __ref: void;

package/dist/components/Screen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Screen.d.ts","sourceRoot":"","sources":["../../src/components/Screen.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAA0B,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAIjE,KAAK,WAAW,GACV,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC,GAC7C,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GACnC,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GACtC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAgB7B,KAAK,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAoB9C;;;;;;;;;GASG;AACH,KAAK,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAmB9C;;;;GAIG;AACH,eAAO,MAAM,MAAM;4BAzEwB,MAAM;;;;;;;;;;;;gCAAN,MAAM;;;;;;;;;gCAAN,MAAM;;;;;;;;;;;;;;;;;;;;;;CA8E/C,CAAC"}
+{"version":3,"file":"Screen.d.ts","sourceRoot":"","sources":["../../src/components/Screen.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAA0B,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAKjE,KAAK,WAAW,GACV,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC,GAC7C,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GACnC,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GACtC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAiB7B,KAAK,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAoB9C;;;;;;;;;GASG;AACH,KAAK,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAmB9C;;;;GAIG;AACH,eAAO,MAAM,MAAM;;;4BA1EwB,MAAM;;;;;;;;;;;;gCAAN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+E/C,CAAC"}

package/dist/components/Stack.d.ts

@@ -1,21 +1,91 @@
-import { type ComponentFactory } from '@sigx/lynx';
+import { type Define } from '@sigx/lynx';
+type StackProps = 
+/**
+ * Mint a nested navigator with this route at its base. When set, the
+ * `<Stack>` becomes the owner of a new `NavigatorState` and provides
+ * `useNav` / `useNavInternals` / `useNavRoutes` to its subtree, so
+ * `nav.push('card-route', …)` from inside the stack stays *inside* it
+ * (e.g. for per-tab stacks). Routes presented as `modal` / `fullScreen` /
+ * `transparent-modal` automatically escalate to the parent navigator
+ * via `nav.parent`, walking up until they reach the root — so modals
+ * still overlay the whole app.
+ *
+ * Omit to render the *enclosing* navigator's stack (the default — this
+ * is how `<NavigationRoot> → <Stack />` works).
+ */
+Define.Prop<'initialRoute', string>
+/** Initial params for the nested-stack base entry. */
+ & Define.Prop<'initialParams', Record<string, unknown>>
+/** Initial search for the nested-stack base entry. */
+ & Define.Prop<'initialSearch', Record<string, unknown>>
+/**
+ * Optional chrome rendered *above* the active screen, **inside this
+ * Stack's nav scope**. The intended use is `<Header />`, which needs
+ * to resolve `useNav()` to the per-stack nav (not the enclosing one)
+ * so it can react to pushes inside this stack — e.g. show a back
+ * button when a card is pushed onto a per-tab stack.
+ *
+ * Without this, a `<Header />` placed as a sibling of `<Stack>`
+ * would see the enclosing nav and never update when pushes happen
+ * inside the nested stack.
+ */
+ & Define.Slot<'default'>;
 /**
  * Stack navigator — renders the topmost stack entry's component at rest, or
  * the top + underneath entries during a transition.
  *
- * **Idle**: just the top entry, full-bleed, no transform. The screen
- * component mounts directly so it can use its own layout (no extra absolute
- * positioning that would break percentage heights).
+ * Two modes:
+ *
+ * **Bound** (no `initialRoute`): renders the enclosing navigator's stack.
+ * This is the shape used directly under `<NavigationRoot>` and is what
+ * single-stack apps want.
+ *
+ * **Nested-owner** (`initialRoute="…"`): mints a fresh `NavigatorState` with
+ * its own progress `SharedValue` and edge-back gesture, and provides
+ * `useNav` / `useNavInternals` / `useNavRoutes` to its subtree. `useNav()`
+ * inside this stack returns the nested nav; `nav.parent` points to the
+ * enclosing one. Per-tab stacks are the canonical use case:
+ *
+ * ```tsx
+ * <Tabs initialTab="trips">
+ *   <Tabs.Screen name="trips"><Stack initialRoute="tripsHome" /></Tabs.Screen>
+ *   <Tabs.Screen name="map"><Stack initialRoute="mapHome" /></Tabs.Screen>
+ * </Tabs>
+ * ```
+ *
+ * Modal/fullScreen pushes escalate up the parent chain automatically — so
+ * `nav.push('newTrip')` from inside Trips (where `newTrip` is `modal`)
+ * walks to root and overlays the whole UI. `replace` stays strictly local
+ * (asymmetric with `push`) so a modal `replace` never wipes the root stack.
+ *
+ * **Render strategy.** Stack always emits the same JSX shape — a
+ * relative wrapper containing one `<Layer>` per entry returned by
+ * `computeLayers(stack, transition, progress)`. Each Layer is an
+ * absolutely-positioned host view with optional MT-bound translate
+ * animation. The pure layer-plan function decides:
  *
- * **Transitioning**: two `<ScreenContainer>` instances stacked absolutely,
- * each with an MT-driven `translateX` that reads from the navigator's
- * progress `SharedValue`. The host's BG thread doesn't tick per frame —
- * `useAnimatedStyle` runs the interpolation entirely on MT.
+ *  - **Idle.** Topmost non-overlay base + any overlays above it. All
+ *    static (no transform). Overlays (`modal` / `fullScreen` /
+ *    `transparent-modal`) keep their underneath mounted; cards
+ *    replace their underneath in the base layer.
+ *  - **Card transition.** Both top and underneath animate (slide-in
+ *    + parallax). After settle, idle rules apply — the underneath
+ *    unmounts because the new top is the sole base.
+ *  - **Overlay transition.** The full idle layer stack up through
+ *    the underneath stays static; only the animated top has a
+ *    transform. After settle, the overlay either joins the static
+ *    idle stack (push) or unmounts (pop).
  *
- * `key={top.key}` keeps the idle render's component instance stable across
- * unrelated re-renders. During transitions, composite keys
- * (`${entry.key}-${role}-${kind}`) ensure a fresh mount per role/kind pair so
- * the `useAnimatedStyle` binding is set with the right input/output ranges.
+ * Layer keys are `layer-${entry.key}-${animationVariant}`. The variant
+ * suffix forces a remount when an entry transitions from animated to
+ * static (or vice versa) — `useAnimatedStyle` binds once at setup and
+ * can't switch its mapper at runtime. Modal underneath layers never
+ * animate, so their key is stable across the modal lifecycle and the
+ * subtree's state (per-tab Stack navigators, scroll positions,
+ * in-flight inputs) survives.
  */
-export declare const Stack: ComponentFactory<{}, void, unknown>;
+export declare const Stack: import("@sigx/runtime-core").ComponentFactory<StackProps, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+export {};
 //# sourceMappingURL=Stack.d.ts.map

package/dist/components/Stack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../src/components/Stack.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,gBAAgB,EAAoB,MAAM,YAAY,CAAC;AAQhF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,qCA2FhB,CAAC"}
+{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../src/components/Stack.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOH,KAAK,MAAM,EACd,MAAM,YAAY,CAAC;AAepB,KAAK,UAAU;AACX;;;;;;;;;;;;GAYG;AACD,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC;AACrC,sDAAsD;GACpD,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD,sDAAsD;GACpD,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD;;;;;;;;;;GAUG;GACD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,KAAK;;EAuPhB,CAAC"}

package/dist/components/TabBar.d.ts

@@ -1,32 +1,31 @@
 /**
- * `<TabBar>` — default chrome for `<Tabs>`.
+ * `<TabBar>` — headless default chrome for `<Tabs>`.
  *
- * Renders a row of tab buttons reading from the enclosing `useTabs()`
- * navigator. Active tab is highlighted via the `active` prop on each
- * default button (consumers can re-style via `renderTab`).
+ * Renders the active-tab buttons reading from the enclosing `useTabs()`
+ * navigator. Intentionally **unstyled** — this lives in the (theme-less)
+ * navigation package, so it ships pure structure + accessibility wiring.
+ * Themed chrome belongs in a UI-kit package: see `<NavTabBar />` in
+ * `@sigx/lynx-daisyui` for the daisy-themed equivalent.
  *
- * Customization knobs:
+ * Use this directly only if you want to handle styling yourself via the
+ * `renderTab` prop. For a "looks like a tab bar out of the box" component,
+ * pull `<NavTabBar />` from `@sigx/lynx-daisyui` (or your own UI kit).
+ *
+ * Customization:
  *   - `renderTab`: a function `(info, ctx) => JSX` that fully replaces the
  *     default button rendering for each tab. `ctx.active` tells the
  *     consumer whether this tab is currently focused; `ctx.onPress`
- *     activates the tab.
- *
- * Accessibility:
- *   - Each default button gets `accessibility-label` from
- *     `info.accessibilityLabel ?? info.label ?? info.name`.
- *   - Each default button gets `accessibility-element="true"` so screen
- *     readers see the whole pill, not just the inner `<text>`.
- *   - Each default button gets `accessibility-trait="button"` and a
- *     `selected` flag on the active one so VoiceOver/TalkBack announces
- *     focus state on tab switch.
+ *     activates the tab. **Recommended** for any visual treatment.
  *
- * Placement: mount inside `<Tabs>` alongside the `<Tabs.Screen>`s. Order
- * matters visually (place above or below the screen bodies depending on
- * the layout), and `<Tabs.Screen>` bodies all stack with `display:flex` so
- * the TabBar should be at a deterministic position in the JSX.
+ * Accessibility (baked into the default button — the one structural
+ * concern this component keeps):
+ *   - `accessibility-label` from `info.accessibilityLabel ?? info.label ?? info.name`.
+ *   - `accessibility-element="true"` so screen readers see the whole pill.
+ *   - `accessibility-trait="button"` and a `selected` flag on the active
+ *     one so VoiceOver/TalkBack announces focus state on tab switch.
  */
 import { type JSXElement } from '@sigx/lynx';
-import { type TabInfo } from './Tabs.js';
+import { type TabInfo } from './Tabs';
 /** Rendering context passed to a `renderTab` consumer. */
 export interface TabRenderContext {
     /** True when this tab is currently active. Reactive — re-runs render on change. */

package/dist/components/TabBar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TabBar.d.ts","sourceRoot":"","sources":["../../src/components/TabBar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAGH,KAAK,UAAU,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAElD,0DAA0D;AAC1D,MAAM,WAAW,gBAAgB;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,2EAA2E;IAC3E,OAAO,IAAI,IAAI,CAAC;CACnB;AAmCD,eAAO,MAAM,MAAM;wBAhCmB,OAAO,OAAO,gBAAgB,KAAK,UAAU;YA4DjF,CAAC"}
+{"version":3,"file":"TabBar.d.ts","sourceRoot":"","sources":["../../src/components/TabBar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAGH,KAAK,UAAU,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,QAAQ,CAAC;AAE/C,0DAA0D;AAC1D,MAAM,WAAW,gBAAgB;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,2EAA2E;IAC3E,OAAO,IAAI,IAAI,CAAC;CACnB;AAoCD,eAAO,MAAM,MAAM;wBAjCmB,OAAO,OAAO,gBAAgB,KAAK,UAAU;YA6DjF,CAAC"}

package/dist/components/Tabs.d.ts

@@ -4,31 +4,32 @@
  * Usage:
  *
  * ```tsx
- * <NavigationRoot routes={routes}>
- *   <Tabs initialTab="feed">
- *     <Tabs.Screen name="feed" icon={<FeedIcon />} label="Feed">
- *       <FeedView />
- *     </Tabs.Screen>
- *     <Tabs.Screen name="me" icon={<MeIcon />} label="Profile">
- *       <ProfileView />
- *     </Tabs.Screen>
- *   </Tabs>
+ * <NavigationRoot routes={routes} initialRoute="root">
+ *   <Stack />
  * </NavigationRoot>
- * ```
  *
- * Scope of this slice (v0.1): pure UI primitive. Each tab's body stays
- * mounted for state preservation (the inactive ones render with
- * `display: 'none'`). Active tab is reactive via `useTabs()`.
+ * // The route "root" component renders:
+ * <Tabs initialTab="feed">
+ *   <Tabs.Screen name="feed" icon={<FeedIcon />} label="Feed">
+ *     <Stack initialRoute="feedHome" />
+ *   </Tabs.Screen>
+ *   <Tabs.Screen name="me" icon={<MeIcon />} label="Profile">
+ *     <Stack initialRoute="profileHome" />
+ *   </Tabs.Screen>
+ *   <TabBar />
+ * </Tabs>
+ * ```
  *
- * Out of scope (deferred to a nested-navigators slice):
- *   - Per-tab `<Stack>` with its own navigator state machine
- *   - `nav.parent` chain into the Tabs nav
- *   - Named navigators (`useNav('root')`)
+ * Tab bodies stay mounted across switches (the inactive ones render with
+ * `display: 'none'`), so each tab's nested `<Stack>` keeps its history when
+ * the user flips back to it. The active tab is reactive via `useTabs()`.
  *
- * Those build on multi-navigator-state plumbing that isn't ready yet.
- * For now, the inner content of a `<Tabs.Screen>` shares the same nav as
- * its outer `<NavigationRoot>` — usable for shallow tab apps, but full
- * nested routing comes later.
+ * Per-tab stacks: each `<Tabs.Screen>` can host a `<Stack initialRoute="…">`
+ * which mints its own navigator. `useNav()` inside that subtree resolves to
+ * the tab's stack, so `nav.push('card-route', …)` stays inside the tab.
+ * Routes presented as `modal` / `fullScreen` / `transparent-modal` escalate
+ * up `nav.parent` to the root navigator automatically — they overlay the
+ * tabs UI (TabBar included) and dismiss back into the originating tab.
  */
 import { type Define, type JSXElement } from '@sigx/lynx';
 /** Metadata about a registered `<Tabs.Screen>`. */
@@ -59,6 +60,14 @@ export interface TabsNav {
  * Access the enclosing Tabs navigator. Throws when called outside `<Tabs>`.
  */
 export declare const useTabs: import("@sigx/runtime-core").InjectableFunction<TabsNav>;
+/**
+ * @internal
+ * Provided by each `<Tabs.Screen>` so a nested `<Stack initialRoute>` can
+ * discover *which* tab it's hosted by, and gate its focus state on that
+ * tab being active. Throws when called outside a `<Tabs.Screen>` body so
+ * the gate degrades to "always active" via the caller's try/catch.
+ */
+export declare const useTabScreenName: import("@sigx/runtime-core").InjectableFunction<string>;
 type TabsProps = Define.Prop<'initialTab', string> & Define.Slot<'default'>;
 type TabsScreenProps = Define.Prop<'name', string, true> & Define.Prop<'icon', JSXElement> & Define.Prop<'label', string> & Define.Prop<'accessibilityLabel', string> & Define.Slot<'default'>;
 /**

package/dist/components/Tabs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tabs.d.ts","sourceRoot":"","sources":["../../src/components/Tabs.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAQH,KAAK,MAAM,EACX,KAAK,UAAU,EAElB,MAAM,YAAY,CAAC;AAEpB,mDAAmD;AACnD,MAAM,WAAW,OAAO;IACpB,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,kDAAkD;AAClD,MAAM,WAAW,OAAO;IACpB,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,0DAIlB,CAAC;AAsBH,KAAK,SAAS,GACR,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GACjC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAgE7B,KAAK,eAAe,GACd,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,GACjC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GAC/B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,GAC5B,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,GACzC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAoC7B;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEf,CAAC"}
+{"version":3,"file":"Tabs.d.ts","sourceRoot":"","sources":["../../src/components/Tabs.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,EAQH,KAAK,MAAM,EACX,KAAK,UAAU,EAElB,MAAM,YAAY,CAAC;AAEpB,mDAAmD;AACnD,MAAM,WAAW,OAAO;IACpB,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,kDAAkD;AAClD,MAAM,WAAW,OAAO;IACpB,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,0DAIlB,CAAC;AAsBH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,yDAI3B,CAAC;AAEH,KAAK,SAAS,GACR,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GACjC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAgE7B,KAAK,eAAe,GACd,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,GACjC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GAC/B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,GAC5B,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,GACzC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAsD7B;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEf,CAAC"}

package/dist/define-routes.d.ts

@@ -1,4 +1,4 @@
-import type { RouteMap } from './types.js';
+import type { RouteMap } from './types';
 /**
  * Define a typed route registry.
  *

package/dist/define-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-routes.d.ts","sourceRoot":"","sources":["../src/define-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAEnE"}
+{"version":3,"file":"define-routes.d.ts","sourceRoot":"","sources":["../src/define-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAEnE"}

package/dist/hooks/use-focus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-focus.d.ts","sourceRoot":"","sources":["../../src/hooks/use-focus.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,KAAK,QAAQ,EAChB,MAAM,YAAY,CAAC;AAIpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,OAAO,CAAC,CAOhD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CA0BlE"}
+{"version":3,"file":"use-focus.d.ts","sourceRoot":"","sources":["../../src/hooks/use-focus.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,KAAK,QAAQ,EAChB,MAAM,YAAY,CAAC;AAIpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,OAAO,CAAC,CAahD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CA0BlE"}