@sigx/lynx-navigation 0.4.0 → 0.4.1

package/src/hooks/use-nav-internal.d.ts

@@ -1,91 +0,0 @@
-import { type SharedValue } from '@sigx/lynx';
-import type { ScreenRegistry } from '../internal/screen-registry';
-import type { RouteMap, StackEntry } from '../types';
-/**
- * Internal injectable: the `StackEntry` the calling screen was rendered for.
- *
- * Provided by `<EntryScope>` which `<Stack>` and `<ScreenContainer>` wrap
- * around each screen component mount. Screens use this to derive their own
- * focus state (`useIsFocused`, `useFocusEffect`) without having to track
- * `entry.key` themselves.
- *
- * Default throws so calling `useIsFocused()` outside a screen mounted by a
- * navigator surfaces a clear error rather than silently returning `false`.
- */
-export declare const useCurrentEntry: import("@sigx/runtime-core").InjectableFunction<StackEntry<string, unknown, unknown>>;
-/**
- * Soft companion to {@link useCurrentEntry} — returns the current scope's
- * entry if any, `null` when called outside an `<EntryScope>` instead of
- * throwing. Provided alongside the strict version by `<EntryScope>`.
- *
- * Used by chrome consumers (`useScreenChrome`) where "no scoped entry"
- * is a legitimate state (a Stack chrome slot lives outside the screen's
- * EntryScope) and the caller wants to soft-fallback to the navigator's
- * destination entry rather than crash.
- */
-export declare const useCurrentEntryOptional: import("@sigx/runtime-core").InjectableFunction<StackEntry<string, unknown, unknown> | null>;
-/**
- * Internal injectable: the route registry passed into `<NavigationRoot>`.
- * Components (Stack, Screen) read this to look up route definitions by name.
- *
- * Not exported from the package barrel — use `useNav()` for navigation, and
- * the registry is implicit from `<NavigationRoot routes={...}>`.
- */
-export declare const useNavRoutes: import("@sigx/runtime-core").InjectableFunction<RouteMap>;
-/**
- * Internal injectable: low-level navigator handles used by the edge-back
- * gesture. Holds the progress SharedValue (so gesture worklets can write it
- * directly on MT) plus BG-side begin/commit/cancel functions invoked via
- * `runOnBackground` from gesture worklets.
- *
- * `progress` is `null` when the navigator was created with `animated={false}`
- * (e.g. tests). `beginBackGesture` is also a no-op in that case.
- */
-export interface NavInternals {
-    /** MT-driven transition progress; null when animations are disabled. */
-    readonly progress: SharedValue<number> | null;
-    /**
-     * Set transition state for a gesture-driven pop. Does not start any
-     * automatic animation — the gesture worklet writes `progress` directly
-     * per frame, then animates to the commit/cancel endpoint on release.
-     */
-    beginBackGesture(): void;
-    /** Commit the back gesture: pop top entry + clear transition. */
-    commitBackGesture(): void;
-    /** Cancel the back gesture: clear transition without popping. */
-    cancelBackGesture(): void;
-    /** Whether the user opted into the edge-swipe-back gesture. */
-    readonly edgeSwipeEnabled: boolean;
-    /**
-     * Cross-entry screen registry controller. `<EntryScope>` calls
-     * `register` on mount and `unregister` on unmount. Persistent chrome
-     * (HeaderBar / TabBar — later slices) calls `get(entryKey)` to read
-     * the focused screen's options + slot fills without remounting itself.
-     */
-    readonly screens: {
-        register(registry: ScreenRegistry): void;
-        /**
-         * Identity-checked: only removes the entry if `registry` is the
-         * one currently registered under its `entry.key`. A no-op when
-         * a newer registry has already taken that slot (which happens
-         * at the transition→idle handoff, where a fresh `<EntryScope>`
-         * for the same entry mounts before the old one's unmount fires).
-         */
-        unregister(registry: ScreenRegistry): void;
-        get(entryKey: string): ScreenRegistry | undefined;
-    };
-}
-export declare const useNavInternals: import("@sigx/runtime-core").InjectableFunction<NavInternals>;
-/**
- * Internal injectable: the calling screen's `ScreenRegistry`.
- *
- * Provided by `<EntryScope>` alongside `useCurrentEntry`. The `<Screen>`
- * component and its slot-filling sub-components write options and slot
- * fills here; the navigator's persistent chrome (HeaderBar, TabBar — later
- * slices) reads from this registry via `getScreenRegistry(key)` on the
- * navigator state, which keys into a cross-entry map.
- *
- * Throws when used outside an EntryScope so calling `<Screen>` at the app
- * root surfaces a clear error rather than silently no-op'ing.
- */
-export declare const useScreenRegistry: import("@sigx/runtime-core").InjectableFunction<ScreenRegistry>;

package/src/hooks/use-nav-serializer.d.ts

@@ -1,82 +0,0 @@
-import type { StackEntry } from '../types';
-/**
- * Plain JSON snapshot of a navigator. The whole point of holding navigation
- * state in signals is that this is a one-liner — `JSON.stringify(nav.stack)`.
- *
- * Shape is deliberately minimal:
- *
- *   {
- *     version: 1,
- *     stack: [ { key, route, params, search, state, presentation }, ... ],
- *   }
- *
- * `version` lets future schema migrations (or hard breakage) reject old
- * snapshots cleanly rather than restoring incompatible state.
- *
- * Per spec resolved-decisions: only the root navigator is persisted in v1.
- * Per-tab / nested-navigator stacks are deferred until the nested-navigators
- * follow-up slice lands.
- */
-export interface NavSnapshot {
-    version: number;
-    stack: StackEntry[];
-}
-export declare const NAV_SNAPSHOT_VERSION = 1;
-/**
- * Adapter contract for `useNavSerializer`. Implementations bridge to whatever
- * storage backend the host app uses — `@sigx/lynx-storage`, `localStorage`,
- * an MMKV bridge, etc. Both methods may be async; the hook awaits load before
- * applying anything to the stack and fires save in a debounced manner.
- *
- *   - `load()` returns `null` (or rejects) when no snapshot exists, when the
- *     stored payload is malformed, or when the host opts not to restore on
- *     this launch.
- *   - `save(snapshot)` persists the latest stack. The hook drops save errors
- *     on the floor — losing a write is preferable to crashing the navigator.
- */
-export interface NavStorageAdapter {
-    load(): Promise<NavSnapshot | null> | NavSnapshot | null;
-    save(snapshot: NavSnapshot): Promise<void> | void;
-}
-export interface UseNavSerializerOptions {
-    storage: NavStorageAdapter;
-    /**
-     * Trailing-edge debounce in ms before pushing a stack change to storage.
-     * Defaults to 250ms — quick enough that a force-quit one tick after a
-     * push is recoverable, slow enough that rapid `pop/push` flurries
-     * coalesce into one write.
-     */
-    debounceMs?: number;
-    /**
-     * Optional callback after a successful restore — lets the host run
-     * post-restore wiring (analytics, focus shifts, etc.) only when we
-     * actually applied state, not on every mount.
-     */
-    onRestored?: (snapshot: NavSnapshot) => void;
-    /**
-     * Optional callback when a snapshot is rejected (validation failed or
-     * load threw). Defaults to silent. Useful for logging during migration.
-     */
-    onRestoreError?: (reason: 'version' | 'shape' | 'unknown-route' | 'load-threw', err?: unknown) => void;
-}
-/**
- * Wire a navigator's stack to a storage adapter.
- *
- * On mount:
- *   1. Call `storage.load()`.
- *   2. Validate the snapshot (version match, every entry's route still
- *      registered).
- *   3. On success, `nav.reset({ stack })` to apply.
- *   4. On any failure, leave the stack alone (initial route remains).
- *
- * Then subscribe to `nav.stack` and call `storage.save(snapshot)` debounced.
- *
- * Why we don't validate `params` / `search` against schemas here: schemas
- * are part of the route definition, and re-running them across all entries
- * on every launch costs more than it's worth. The contract is "entries were
- * validated when they were pushed; if the schema has since changed in a
- * breaking way, bump `version` to reject old snapshots wholesale." Callers
- * who want a stricter check can run their own validation in
- * `storage.load()` and return `null` on mismatch.
- */
-export declare function useNavSerializer(options: UseNavSerializerOptions): void;

package/src/hooks/use-nav.d.ts

@@ -1,111 +0,0 @@
-import type { RegisteredRoutes, RouteId, RouteParams, RouteSearch } from '../register';
-import type { PopOptions, PushOptions, RouteRequiresParams, StackEntry, TransitionState } from '../types';
-/**
- * Subset of registered route names that declare a `params` schema (and so
- * require a `params` argument when navigating).
- *
- * Computed via mapped-type filtering rather than a conditional inside the
- * method signature: when a conditional like `RouteRequiresParams<R[K]>` is
- * embedded inside a generic method parameter, TS evaluates it at definition
- * time with K bound to the *whole* union of route ids — which distributes
- * `RouteRequiresParams` over every route and collapses the result to
- * `boolean`, breaking the conditional. Filtering once at the type level avoids
- * the issue and produces clean overload candidates.
- */
-export type RoutesWithParams = {
-    [K in RouteId]: RouteRequiresParams<RegisteredRoutes[K]> extends true ? K : never;
-}[RouteId];
-/** Routes that don't declare a `params` schema. */
-export type RoutesWithoutParams = Exclude<RouteId, RoutesWithParams>;
-/**
- * The navigator handle returned by `useNav()`.
- *
- * Read access (`current`, `stack`, `canGoBack`) is reactive — these properties
- * are getters that read from the underlying stack signal, so accessing them
- * inside a component's render function (or inside `effect` / `computed`) takes
- * a reactive dependency. Mutating methods (`push`, `pop`, etc.) trigger the
- * dependents to update.
- *
- * `push` and `replace` are split into two overloads — one for routes without a
- * params schema (no params arg) and one for routes with a params schema
- * (params required). See `RoutesWithParams` above for why this isn't a single
- * conditional return type.
- */
-export interface Nav {
-    /** Push a route that has no params schema. */
-    push<K extends RoutesWithoutParams>(name: K, search?: RouteSearch<K>, options?: PushOptions): void;
-    /** Push a route that requires params. */
-    push<K extends RoutesWithParams>(name: K, params: RouteParams<K>, search?: RouteSearch<K>, options?: PushOptions): void;
-    /** Replace the top entry — same overload pattern as push. */
-    replace<K extends RoutesWithoutParams>(name: K, search?: RouteSearch<K>, options?: PushOptions): void;
-    replace<K extends RoutesWithParams>(name: K, params: RouteParams<K>, search?: RouteSearch<K>, options?: PushOptions): void;
-    /** Pop one or more entries off the top of the stack. */
-    pop(count?: number, options?: PopOptions): void;
-    /** Pop entries until the named route is at the top. */
-    popTo<K extends RouteId>(name: K): void;
-    /** Pop all the way to the root entry. */
-    popToRoot(): void;
-    /** Wholesale-replace the stack. */
-    reset(state: {
-        stack: ReadonlyArray<StackEntry>;
-    }): void;
-    /** Dismiss the topmost modal stack (no-op if none active). */
-    dismiss(): void;
-    /** Currently-focused entry. Reactive via property access. */
-    readonly current: StackEntry;
-    /** Full stack, top last. Reactive. */
-    readonly stack: ReadonlyArray<StackEntry>;
-    /** Whether the user can go back from the current entry. Reactive. */
-    readonly canGoBack: boolean;
-    /**
-     * Parent navigator (e.g. the root nav above a per-tab `<Stack>`), or null
-     * at the root. Set when a `<Stack>` mints its own navigator via
-     * `<Stack initialRoute="…">` — that stack's `useNav()` returns a nav
-     * whose `parent` is the enclosing nav.
-     *
-     * `push` calls for routes whose resolved presentation is non-`card`
-     * (`modal` / `fullScreen` / `transparent-modal`) escalate up the
-     * `parent` chain automatically — you don't normally need to reach
-     * through `parent` to present modals. `parent` is exposed as an escape
-     * hatch for power users (e.g. imperative `parent.pop()` from a child
-     * stack). Avoid pushing card routes onto `parent` directly — that
-     * defeats per-tab stack isolation.
-     */
-    readonly parent: Nav | null;
-    /**
-     * Whether this navigator is part of the currently-focused chain. True
-     * for the root nav at all times; for a nested nav (e.g. a per-tab
-     * stack), true only when its host entry is the top of `parent`, the
-     * parent itself is locally focused, and any extra gate (e.g. the
-     * enclosing tab is active) reports active.
-     *
-     * Reactive. `useIsFocused()` ANDs `nav.current.key === myKey` with
-     * `nav.isLocallyFocused`.
-     */
-    readonly isLocallyFocused: boolean;
-    /**
-     * @internal
-     * Set of child navigators (per-tab `<Stack>` instances) that have
-     * registered themselves under this nav. Used by `useHardwareBack` to
-     * find the deepest currently-focused nav and route the back press
-     * there before falling back up the chain.
-     *
-     * Not part of the public API — leading-underscore marks it as
-     * implementation detail.
-     */
-    readonly _children: Set<Nav>;
-    /**
-     * In-flight transition, or null when navigation is at rest. Reactive —
-     * `<Stack>` reads this to decide whether to render one screen or two
-     * (during a slide transition both the outgoing and incoming screens
-     * stay mounted with `useAnimatedStyle`-driven transforms).
-     */
-    readonly transition: TransitionState | null;
-}
-/**
- * Access the innermost navigator. Provided by `<NavigationRoot>` via
- * `defineProvide`. Throws when called outside a NavigationRoot subtree.
- *
- * Mirrors `@sigx/router`'s `useRouter` pattern (`packages/router/src/router.ts:30`).
- */
-export declare const useNav: import("@sigx/runtime-core").InjectableFunction<Nav>;

package/src/hooks/use-screen-chrome.d.ts

@@ -1,18 +0,0 @@
-import type { ScreenSlotFills } from '../types';
-export interface ScreenChrome {
-    /** Resolved screen title — `options.title` (string or getter) or the route name as fallback. Reactive. */
-    readonly title: string;
-    /** Whether the header should render. Defaults to true unless the screen set `headerShown: false`. Reactive. */
-    readonly headerShown: boolean;
-    /** True when the current stack has more than one entry — i.e. there's something to pop back to. Reactive. */
-    readonly canGoBack: boolean;
-    /** Pop the top entry. No-op when `!canGoBack`. */
-    pop(): void;
-    /** Full header override slot, if `<Screen.Header>` was set. Render its return value in place of the default layout. */
-    readonly header: ScreenSlotFills['header'] | undefined;
-    /** Left-aligned slot (typically a back button). Reactive. */
-    readonly headerLeft: ScreenSlotFills['headerLeft'] | undefined;
-    /** Right-aligned slot (typically actions). Reactive. */
-    readonly headerRight: ScreenSlotFills['headerRight'] | undefined;
-}
-export declare function useScreenChrome(): ScreenChrome;

package/src/hooks/use-screen-options.d.ts

@@ -1,2 +0,0 @@
-import type { ScreenOptions } from '../types';
-export declare function useScreenOptions(optionsOrFn: ScreenOptions | (() => ScreenOptions)): void;

package/src/href.d.ts

@@ -1,54 +0,0 @@
-import type { RouteId, RouteParams, RouteSearch } from './register';
-import type { RoutesWithoutParams, RoutesWithParams } from './hooks/use-nav';
-/**
- * A typed reference to a navigation target — what `<Link to={...}>` consumes
- * and what `hrefFor()` produces.
- *
- * Holds both the typed pieces (route name, params, search) and the serialized
- * URL form (when the route declares a `path` template). Either side can drive
- * navigation — typed for in-app links, URL for deep links / sharing.
- */
-export interface Href<K extends RouteId = RouteId> {
-    readonly route: K;
-    readonly params: RouteParams<K>;
-    readonly search: RouteSearch<K>;
-    /** URL form. `null` when the route declares no `path` template. */
-    readonly url: string | null;
-}
-/**
- * Build a typed Href for a given route. Validates params against the route's
- * schema at runtime; type-checks them at compile time.
- *
- * Overloaded the same way as `nav.push` — one signature for routes without a
- * params schema, one for routes that require params. See `RoutesWithParams`
- * in `./hooks/use-nav.js` for why this isn't expressed as a single conditional.
- *
- * Requires a `<NavigationRoot>` (or an explicit `_setRouteRegistry` call) to
- * have run — the URL form is built against the active route registry. The
- * typed pieces (`route`, `params`, `search`) are returned regardless; `url`
- * is `null` when the route declares no `path` template.
- *
- * Schema validation errors throw — pass already-validated values from
- * `useParams` / `useSearch` to round-trip safely, or wrap in try/catch when
- * building hrefs from external input.
- *
- * @example
- * ```ts
- * hrefFor('profile', { id: '42' });               // → { route, params, search: {}, url: '/users/42' }
- * hrefFor('profile', { id: '42' }, { tab: 'about' });
- * hrefFor('home');                                // params arg omitted (no schema)
- * ```
- */
-export declare function hrefFor<K extends RoutesWithoutParams>(name: K, search?: RouteSearch<K>): Href<K>;
-export declare function hrefFor<K extends RoutesWithParams>(name: K, params: RouteParams<K>, search?: RouteSearch<K>): Href<K>;
-/**
- * Parse a URL string into a typed Href against the registered routes.
- * Returns `null` if no route's `path` template matches the URL or if the
- * extracted params/search fail the route's schema validation.
- *
- * Accepts both absolute (`myapp://host/path?q`) and pathname-only
- * (`/path?q`) forms — the pathname is matched against each route's
- * compiled template. Iteration order is the registration order; first match
- * wins.
- */
-export declare function parseHref(url: string): Href | null;

package/src/index.d.ts

@@ -1,39 +0,0 @@
-/**
- * @sigx/lynx-navigation — type-first native stack router.
- *
- * Phase 0.1 (current): typed registry, stack runtime, NavigationRoot + Stack.
- * Coming next: Screen with slot-based header API, MTS transitions, Tabs.
- */
-export { defineRoutes } from './define-routes';
-export type { Register, RegisteredRoutes, RouteId, RouteParams, RouteSearch } from './register';
-export { useNav } from './hooks/use-nav';
-export type { Nav, RoutesWithoutParams, RoutesWithParams } from './hooks/use-nav';
-export { useParams } from './hooks/use-params';
-export { useSearch } from './hooks/use-search';
-export { useHardwareBack } from './hooks/use-hardware-back';
-export { useLinkingNav } from './hooks/use-linking-nav';
-export type { UseLinkingNavOptions } from './hooks/use-linking-nav';
-export { useIsFocused, useFocusEffect } from './hooks/use-focus';
-export { useScreenOptions } from './hooks/use-screen-options';
-export { useScreenChrome } from './hooks/use-screen-chrome';
-export type { ScreenChrome } from './hooks/use-screen-chrome';
-export { useNavSerializer, NAV_SNAPSHOT_VERSION, } from './hooks/use-nav-serializer';
-export type { NavSnapshot, NavStorageAdapter, UseNavSerializerOptions, } from './hooks/use-nav-serializer';
-export { hrefFor, parseHref } from './href';
-export type { Href } from './href';
-export { _setRouteRegistry, _clearRouteRegistry } from './url/registry';
-export { compilePath } from './url/compile';
-export type { CompiledPath } from './url/compile';
-export { NavigationRoot } from './components/NavigationRoot';
-export { Stack } from './components/Stack';
-export { Screen } from './components/Screen';
-export { Header } from './components/Header';
-export { Tabs, useTabs } from './components/Tabs';
-export type { TabInfo, TabsNav } from './components/Tabs';
-export { TabBar } from './components/TabBar';
-export type { TabRenderContext } from './components/TabBar';
-export { Drawer, useDrawer } from './components/Drawer';
-export type { DrawerNav } from './components/Drawer';
-export { Link } from './components/Link';
-export type { LinkProps } from './components/Link';
-export type { ComponentLike, EmptyParams, InferOutput, ParamsOf, PopOptions, Presentation, PushOptions, RouteDefinition, RouteMap, RouteRequiresParams, ScreenOptions, ScreenSlotFills, SearchOf, StackEntry, StandardSchemaV1, TransitionKind, TransitionRole, TransitionState, } from './types';

package/src/internal/layer-plan.d.ts

@@ -1,68 +0,0 @@
-/**
- * Pure layer-plan computation for `<Stack>`'s render.
- *
- * Given (stack, transition, progress), produces an ordered list of
- * `Layer`s — each is an entry to render plus an optional transform
- * spec for animation. The Stack render emits one absolutely-positioned
- * `<view>` per layer, stacked bottom-to-top in document order.
- *
- * Why this is its own module: the layer-selection logic is the only
- * non-obvious part of the navigator's render path, and the rules are
- * easier to read (and unit-test) as a pure function over the
- * navigator's state than as inline render branches.
- *
- * Rules:
- *
- *  - **Idle (no transition).** Render the topmost non-overlay entry
- *    as the base, plus every overlay entry above it. Overlays
- *    (`modal` / `fullScreen` / `transparent-modal`) keep their
- *    underneath mounted; cards replace their underneath in the base
- *    layer.
- *
- *  - **Card transition.** Two layers: the underneath entry (animated
- *    with the parallax-card-underneath spec) and the top entry
- *    (animated with the slide-in-from-right spec). After the
- *    transition completes, the idle rule kicks in — the underneath
- *    unmounts because the new top becomes the sole base.
- *
- *  - **Overlay transition.** The full idle layer stack up through the
- *    underneath entry stays static (no transform). The animated top
- *    is the only layer with a transform. After the transition, the
- *    overlay either joins the static idle stack (push) or unmounts
- *    (pop).
- *
- * The Layer.key for the Stack render is
- * `layer-${entry.key}-${animVariant(layer.animation)}`. The variant
- * suffix forces a remount when an entry transitions from animated to
- * static (or vice versa) — `useAnimatedStyle` can't re-bind mid-life,
- * so we get a fresh `useAnimatedStyle` call per animation state.
- * Modal underneath layers never animate, so they stay statically
- * keyed across the modal lifecycle and their state (per-tab Stack,
- * scroll, in-flight inputs) survives.
- */
-import type { SharedValue } from '@sigx/lynx';
-import type { Presentation, StackEntry, TransitionState } from '../types';
-export type LayerAnimation = {
-    axis: 'translateX' | 'translateY';
-    inputRange: readonly [number, number];
-    outputRange: readonly [number, number];
-    progress: SharedValue<number>;
-};
-export interface Layer {
-    /** The entry whose component renders inside this layer. */
-    readonly entry: StackEntry;
-    /** When non-null, the layer's host view binds a `useAnimatedStyle` mapper. */
-    readonly animation: LayerAnimation | null;
-}
-export declare function isOverlayPresentation(p: Presentation): boolean;
-/**
- * Suffix used in a layer's render key. Stable for the layer's
- * lifetime (same entry, same animation kind) and changes when the
- * animation transitions on/off so the Layer remounts and rebinds.
- */
-export declare function animationVariant(animation: LayerAnimation | null): string;
-/**
- * Compute the visible-layer list for one render of `<Stack>`. Pure —
- * unit-testable independently of the renderer.
- */
-export declare function computeLayers(stack: readonly StackEntry[], transition: TransitionState | null, progress: SharedValue<number> | null): Layer[];

package/src/navigator/core.d.ts

@@ -1,96 +0,0 @@
-import { type SharedValue } from '@sigx/lynx';
-import type { Nav } from '../hooks/use-nav';
-import type { ScreenRegistry } from '../internal/screen-registry';
-import type { RouteMap, StackEntry } from '../types';
-/**
- * The reactive backing state for one navigator instance.
- *
- * Two reactive signals drive the public surface:
- *   - `stack` is the entry array (read via `nav.stack` / `nav.current`).
- *   - `transition` is non-null only while a push/pop animation is in flight;
- *     `<Stack>` reads it to decide whether to render one screen or two.
- *
- * Pop is committed *after* its slide animation completes — `nav.canGoBack`
- * stays true during the slide, then flips when the entry actually leaves the
- * stack. Push commits its stack mutation immediately and animates the new
- * entry in.
- */
-export interface NavigatorState {
-    readonly nav: Nav;
-    readonly routes: RouteMap;
-    /**
-     * Internal: BG-side gesture-back controller used by `<EdgeBackHandle>`.
-     * The `progress` SharedValue is wired here so a gesture worklet can write
-     * it directly on MT; the begin/commit/cancel methods set the transition
-     * state appropriately without driving their own auto-animation (the
-     * gesture worklet is in charge of that).
-     */
-    readonly _gesture: {
-        beginBackGesture(): void;
-        commitBackGesture(): void;
-        cancelBackGesture(): void;
-    };
-    /**
-     * Internal: cross-entry `<Screen>` registry lookup.
-     *
-     * Each `<EntryScope>` registers its `ScreenRegistry` here on mount and
-     * removes it on unmount. The navigator's persistent chrome (HeaderBar /
-     * TabBar, shipped in later slices) calls `getScreenRegistry(entry.key)`
-     * to read the currently-focused screen's options/slot fills without
-     * being itself remounted on each navigation.
-     *
-     * Returns `undefined` when no screen for that key has mounted yet (or
-     * after it has unmounted) — consumers must tolerate this and render
-     * defaults.
-     */
-    readonly _screens: {
-        register(registry: ScreenRegistry): void;
-        /** Identity-checked: no-op when a newer registry has taken the slot. */
-        unregister(registry: ScreenRegistry): void;
-        get(entryKey: string): ScreenRegistry | undefined;
-    };
-    /**
-     * Internal: set `nav.isLocallyFocused` from outside.
-     *
-     * `<Stack>` calls this when its host entry's locally-focused state
-     * changes (top of parent + parent focused + enclosing tab active). For
-     * the root nav this stays `true` for the lifetime of the navigator.
-     */
-    readonly _setLocallyFocused: (focused: boolean) => void;
-}
-export interface CreateNavigatorOptions {
-    routes: RouteMap;
-    initial: StackEntry;
-    /**
-     * SharedValue driving push/pop transition progress. Created in
-     * `<NavigationRoot>` setup via `useSharedValue(0)` so the bridge
-     * plumbing is wired (SharedValue is an MT-bridged ref). When undefined,
-     * navigations are instant — used by tests against `@sigx/lynx-testing`
-     * that don't have an MT runtime.
-     */
-    progress?: SharedValue<number>;
-    /**
-     * Parent navigator. Set when this navigator is nested under another
-     * (e.g. a per-tab `<Stack initialRoute>` under root). Drives the
-     * `nav.parent` getter and the modal-escalation behaviour of `push`:
-     * a push of a route whose resolved presentation is not `'card'`
-     * recurses via `parent.push(...)`, walking up the chain until it
-     * lands on a navigator with no parent (the root).
-     *
-     * Leave undefined for the root navigator.
-     */
-    parent?: Nav | null;
-    /**
-     * Whether this navigator is considered "locally focused" at creation
-     * time. Defaults to true for the root nav; nested stacks pass `false`
-     * here and then flip the flag via `_setLocallyFocused` once their
-     * host-entry/tab-active state is computed.
-     */
-    initialLocallyFocused?: boolean;
-}
-/**
- * Create a navigator. Returns the public `nav` handle plus the routes map.
- * The transition signal lives on `nav` (via `nav.transition`) so `<Stack>`
- * can subscribe to it.
- */
-export declare function createNavigatorState(opts: CreateNavigatorOptions): NavigatorState;

package/src/register.d.ts

@@ -1,37 +0,0 @@
-import type { ParamsOf, RouteMap, SearchOf } from './types';
-/**
- * Module-augmentation surface for the user's typed route map.
- *
- * Apps register their routes by augmenting this interface — the rest of the
- * library's typed APIs (useNav, useParams, useSearch, <Link>) read from
- * `RegisteredRoutes` so all inference is global.
- *
- * @example
- * ```ts
- * // In your app's main.ts (or a routes.ts that's imported early):
- * import type { routes } from './routes';
- *
- * declare module '@sigx/lynx-navigation' {
- *     interface Register { routes: typeof routes }
- * }
- * ```
- *
- * If `Register.routes` is not augmented the library falls back to a permissive
- * `RouteMap` so non-augmented usage still type-checks (just without precise
- * inference). The recommended pattern is always to augment.
- */
-export interface Register {
-}
-/**
- * The user's registered route map, or a permissive fallback when not
- * augmented. All higher-level types derive from this.
- */
-export type RegisteredRoutes = Register extends {
-    routes: infer R;
-} ? R : RouteMap;
-/** Union of registered route names (string literal union when registered). */
-export type RouteId = keyof RegisteredRoutes & string;
-/** Params type for a registered route name. */
-export type RouteParams<K extends RouteId> = ParamsOf<RegisteredRoutes[K]>;
-/** Search type for a registered route name. */
-export type RouteSearch<K extends RouteId> = SearchOf<RegisteredRoutes[K]>;