@vertz/ui 0.2.0 → 0.2.2

package/dist/jsx-runtime/index.d.ts

@@ -1,31 +1,50 @@
 /**
-* JSX runtime for @vertz/ui — used by Bun at test/dev time.
-*
-* At build time, the @vertz/ui-compiler transforms JSX into optimized
-* __element() / __on() / __text() / __attr() calls with compile-time
-* reactivity analysis. This runtime provides a simpler DOM-based
-* implementation for tests and development.
-*
-* Implements the "react-jsx" automatic runtime interface:
-* - jsx(type, props)  — single child
-* - jsxs(type, props) — multiple children
-* - Fragment          — document fragment
+* JSX namespace - required for TypeScript's react-jsx mode
+* to understand intrinsic element types and component types.
 */
-type JSXComponent = (props: Record<string, unknown>) => Node | Node[] | null;
-type Tag = string | JSXComponent;
+declare namespace JSX {
+	type Element = HTMLElement | SVGElement;
+	type JSXComponent = (props: Record<string, unknown>) => Element;
+	interface HTMLAttributes {
+		[key: string]: unknown;
+		children?: unknown;
+	}
+	interface IntrinsicAttributes {
+		key?: string | number;
+	}
+	interface IntrinsicElements {
+		[key: string]: HTMLAttributes | undefined;
+	}
+}
 /**
 * JSX factory function for client-side rendering.
 *
 * When tag is a function (component), calls it with props.
 * When tag is a string (HTML element), creates a DOM element.
 */
-declare function jsx(tag: Tag, props: Record<string, unknown>): Node | Node[] | null;
+declare function jsx<K extends keyof HTMLElementTagNameMap>(tag: K, props: Record<string, unknown> | null | undefined): HTMLElementTagNameMap[K];
+declare function jsx(tag: string, props: Record<string, unknown> | null | undefined): HTMLElement;
+declare function jsx<
+	P extends Record<string, unknown>,
+	R extends JSX.Element
+>(tag: (props: P) => R, props: P): R;
+declare function jsx(tag: typeof Fragment, props: {
+	children?: unknown;
+}): DocumentFragment;
 /**
 * JSX factory for elements with multiple children.
 * In the automatic runtime, this is used when there are multiple children.
 * For our implementation, it's the same as jsx().
 */
-declare const jsxs: typeof jsx;
+declare function jsxs<K extends keyof HTMLElementTagNameMap>(tag: K, props: Record<string, unknown> | null | undefined): HTMLElementTagNameMap[K];
+declare function jsxs(tag: string, props: Record<string, unknown> | null | undefined): HTMLElement;
+declare function jsxs<
+	P extends Record<string, unknown>,
+	R extends JSX.Element
+>(tag: (props: P) => R, props: P): R;
+declare function jsxs(tag: typeof Fragment, props: {
+	children?: unknown;
+}): DocumentFragment;
 /**
 * Fragment component — a DocumentFragment container for multiple children.
 */
@@ -36,5 +55,13 @@ declare function Fragment(props: {
 * JSX development mode factory (used with @jsxImportSource in tsconfig).
 * Same as jsx() for our implementation.
 */
-declare const jsxDEV: typeof jsx;
-export { jsxs, jsxDEV, jsx, Fragment };
+declare function jsxDEV<K extends keyof HTMLElementTagNameMap>(tag: K, props: Record<string, unknown> | null | undefined): HTMLElementTagNameMap[K];
+declare function jsxDEV(tag: string, props: Record<string, unknown> | null | undefined): HTMLElement;
+declare function jsxDEV<
+	P extends Record<string, unknown>,
+	R extends JSX.Element
+>(tag: (props: P) => R, props: P): R;
+declare function jsxDEV(tag: typeof Fragment, props: {
+	children?: unknown;
+}): DocumentFragment;
+export { jsxs, jsxDEV, jsx, JSX, Fragment };

package/dist/jsx-runtime/index.js

@@ -1,7 +1,17 @@
+import {
+  SVG_NS,
+  isSVGTag,
+  normalizeSVGAttr
+} from "../shared/chunk-prj7nm08.js";
+
 // src/jsx-runtime/index.ts
 function applyChildren(parent, children) {
   if (children == null || children === false || children === true)
     return;
+  if (typeof children === "function") {
+    applyChildren(parent, children());
+    return;
+  }
   if (Array.isArray(children)) {
     for (const child of children) {
       applyChildren(parent, child);
@@ -12,36 +22,45 @@ function applyChildren(parent, children) {
     parent.appendChild(document.createTextNode(String(children)));
   }
 }
-function jsx(tag, props) {
+function jsxImpl(tag, props) {
   if (typeof tag === "function") {
-    return tag(props);
+    return tag(props || {});
   }
   const { children, ...attrs } = props || {};
-  const element = document.createElement(tag);
+  const svg = isSVGTag(tag);
+  const element = svg ? document.createElementNS(SVG_NS, tag) : document.createElement(tag);
   for (const [key, value] of Object.entries(attrs)) {
     if (key.startsWith("on") && typeof value === "function") {
       const eventName = key.slice(2).toLowerCase();
       element.addEventListener(eventName, value);
     } else if (key === "class" && value != null) {
-      element.className = String(value);
+      element.setAttribute("class", String(value));
     } else if (key === "style" && value != null) {
       element.setAttribute("style", String(value));
     } else if (value === true) {
       element.setAttribute(key, "");
     } else if (value != null && value !== false) {
-      element.setAttribute(key, String(value));
+      const attrName = svg ? normalizeSVGAttr(key) : key;
+      element.setAttribute(attrName, String(value));
     }
   }
   applyChildren(element, children);
   return element;
 }
-var jsxs = jsx;
+function jsx(tag, props) {
+  return jsxImpl(tag, props);
+}
+function jsxs(tag, props) {
+  return jsxImpl(tag, props);
+}
 function Fragment(props) {
   const frag = document.createDocumentFragment();
   applyChildren(frag, props?.children);
   return frag;
 }
-var jsxDEV = jsx;
+function jsxDEV(tag, props) {
+  return jsxImpl(tag, props);
+}
 export {
   jsxs,
   jsxDEV,

package/dist/query/public.d.ts

@@ -1,3 +1,5 @@
+import { QueryDescriptor as QueryDescriptor2 } from "@vertz/fetch";
+import { isQueryDescriptor } from "@vertz/fetch";
 /**
 * Interface for cache stores used by query().
 * Consumers can provide custom implementations (e.g. LRU, persistent storage).
@@ -6,7 +8,9 @@ interface CacheStore<T = unknown> {
 	get(key: string): T | undefined;
 	set(key: string, value: T): void;
 	delete(key: string): void;
+	clear?(): void;
 }
+import { QueryDescriptor } from "@vertz/fetch";
 /**
 * A read-only reactive value derived from other signals.
 */
@@ -16,6 +20,17 @@ interface ReadonlySignal<T> {
 	/** Read the current value without subscribing. */
 	peek(): T;
 }
+/**
+* Unwraps a ReadonlySignal to its value type.
+* Used by signal APIs (like query()) to expose plain values in TypeScript
+* while the compiler auto-unwraps them at runtime.
+*
+* @example
+* type UnwrappedData = Unwrapped<ReadonlySignal<Task | undefined>>; // → Task | undefined
+*/
+type Unwrapped<T> = T extends ReadonlySignal<infer U> ? U : T;
+/** Dispose function returned by effect(). */
+type DisposeFn = () => void;
 /** Options for query(). */
 interface QueryOptions<T> {
 	/** Pre-populated data — skips the initial fetch when provided. */
@@ -28,15 +43,33 @@ interface QueryOptions<T> {
 	key?: string;
 	/** Custom cache store. Defaults to a shared in-memory Map. */
 	cache?: CacheStore<T>;
+	/** Timeout in ms for SSR data loading. Default: 300. Set to 0 to disable. */
+	ssrTimeout?: number;
+	/**
+	* Polling interval in ms, or a function for dynamic intervals.
+	*
+	* - `number` — fixed interval in ms
+	* - `false` or `0` — disabled
+	* - `(data, iteration) => number | false` — called after each fetch to
+	*   determine the next interval. Return `false` to stop polling.
+	*   `iteration` counts polls since the last start/restart (resets to 0
+	*   when the function returns `false`).
+	*/
+	refetchInterval?: number | false | ((data: T | undefined, iteration: number) => number | false);
 }
 /** The reactive object returned by query(). */
-interface QueryResult<T> {
+interface QueryResult<
+	T,
+	E = unknown
+> {
 	/** The fetched data, or undefined while loading. */
-	readonly data: ReadonlySignal<T | undefined>;
-	/** True while a fetch is in progress. */
-	readonly loading: ReadonlySignal<boolean>;
+	readonly data: Unwrapped<ReadonlySignal<T | undefined>>;
+	/** True only on the initial load (no data yet). False during revalidation. */
+	readonly loading: Unwrapped<ReadonlySignal<boolean>>;
+	/** True when refetching while stale data is already available. */
+	readonly revalidating: Unwrapped<ReadonlySignal<boolean>>;
 	/** The error from the latest failed fetch, or undefined. */
-	readonly error: ReadonlySignal<unknown>;
+	readonly error: Unwrapped<ReadonlySignal<E | undefined>>;
 	/** Manually trigger a refetch (clears cache for this key). */
 	refetch: () => void;
 	/** Alias for refetch — revalidate the cached data. */
@@ -50,9 +83,42 @@ interface QueryResult<T> {
 * The thunk is wrapped in an effect so that when reactive dependencies
 * used *before* the async call change, the query automatically re-fetches.
 *
-* @param thunk - An async function that returns the data.
+* @param source - A QueryDescriptor or an async function that returns the data.
 * @param options - Optional configuration.
 * @returns A QueryResult with reactive signals for data, loading, and error.
 */
+declare function query<
+	T,
+	E
+>(descriptor: QueryDescriptor<T, E>, options?: Omit<QueryOptions<T>, "key">): QueryResult<T, E>;
 declare function query<T>(thunk: () => Promise<T>, options?: QueryOptions<T>): QueryResult<T>;
-export { query, QueryResult, QueryOptions, CacheStore };
+interface QueryMatchHandlers<
+	T,
+	E
+> {
+	loading: () => Node | null;
+	error: (error: E) => Node | null;
+	data: (data: T) => Node | null;
+}
+/**
+* Pattern-match on a QueryResult's exclusive state.
+*
+* Returns a stable `<span style="display:contents">` wrapper that internally
+* manages branch switching (loading/error/data) via a reactive effect.
+* The same wrapper is returned for repeated calls with the same queryResult
+* (cached via WeakMap), enabling __child's stable-node optimization.
+*
+* Priority: loading → error → data.
+*
+* `loading` only fires on the initial load (no data yet).
+* When revalidating with existing data, the `data` handler receives the
+* current data. Access `query.revalidating` from the component scope for
+* revalidation state.
+*/
+declare function queryMatch<
+	T,
+	E
+>(queryResult: QueryResult<T, E>, handlers: QueryMatchHandlers<T, E>): HTMLElement & {
+	dispose: DisposeFn;
+};
+export { queryMatch, query, isQueryDescriptor, QueryResult, QueryOptions, QueryMatchHandlers, QueryDescriptor2 as QueryDescriptor, CacheStore };

package/dist/query/public.js

@@ -1,7 +1,15 @@
 import {
-  query
-} from "../shared/chunk-zbbvx05f.js";
-import"../shared/chunk-pgymxpn1.js";
+  query,
+  queryMatch
+} from "../shared/chunk-hh0dhmb4.js";
+import"../shared/chunk-jrtrk5z4.js";
+import"../shared/chunk-g4rch80a.js";
+import"../shared/chunk-hrd0mft1.js";
+
+// src/query/public.ts
+import { isQueryDescriptor } from "@vertz/fetch";
 export {
-  query
+  queryMatch,
+  query,
+  isQueryDescriptor
 };

package/dist/router/public.d.ts

@@ -25,9 +25,34 @@ type ExtractParams<T extends string> = [ExtractParamsFromSegments<WithoutWildcar
 } : Record<string, never> : HasWildcard<T> extends true ? { [K in ExtractParamsFromSegments<WithoutWildcard<T>>] : string } & {
 	"*": string;
 } : { [K in ExtractParamsFromSegments<WithoutWildcard<T>>] : string };
+/**
+* Convert a route pattern to the union of URL shapes it accepts.
+* - Static: `'/'` → `'/'`
+* - Param: `'/tasks/:id'` → `` `/tasks/${string}` ``
+* - Wildcard: `'/files/*'` → `` `/files/${string}` ``
+* - Multi: `'/users/:id/posts/:postId'` → `` `/users/${string}/posts/${string}` ``
+* - Fallback: `string` → `string` (backward compat)
+*/
+type PathWithParams<T extends string> = T extends `${infer Before}*` ? `${PathWithParams<Before>}${string}` : T extends `${infer Before}:${string}/${infer After}` ? `${Before}${string}/${PathWithParams<`${After}`>}` : T extends `${infer Before}:${string}` ? `${Before}${string}` : T;
+/**
+* Union of all valid URL shapes for a route map.
+* Maps each route pattern key through `PathWithParams` to produce the accepted URL shapes.
+*
+* Example:
+* ```
+* RoutePaths<{ '/': ..., '/tasks/:id': ... }> = '/' | `/tasks/${string}`
+* ```
+*/
+type RoutePaths<TRouteMap extends Record<string, unknown>> = { [K in keyof TRouteMap & string] : PathWithParams<K> }[keyof TRouteMap & string];
 /** Simple schema interface for search param parsing. */
 interface SearchParamSchema<T> {
-	parse(data: unknown): T;
+	parse(data: unknown): {
+		ok: true;
+		data: T;
+	} | {
+		ok: false;
+		error: unknown;
+	};
 }
 /** A route configuration for a single path. */
 interface RouteConfig<
@@ -55,6 +80,46 @@ interface RouteConfig<
 interface RouteDefinitionMap {
 	[pattern: string]: RouteConfig;
 }
+/**
+* Loose route config used as the generic constraint for `defineRoutes`.
+* Uses `Record<string, string>` for loader params so any concrete loader
+* that accesses string params (e.g., `params.id`) satisfies the constraint.
+*/
+interface RouteConfigLike {
+	component: () => Node | Promise<{
+		default: () => Node;
+	}>;
+	/**
+	* Method syntax (`loader?(ctx): R`) is intentional — it enables **bivariant**
+	* parameter checking under `strictFunctionTypes`. Property syntax
+	* (`loader?: (ctx) => R`) would be contravariant, causing `RouteConfig<string>`
+	* (whose loader has `params: Record<string, never>`) to fail assignability
+	* against this constraint's `params: Record<string, string>`.
+	*/
+	loader?(ctx: {
+		params: Record<string, string>;
+		signal: AbortSignal;
+	}): unknown;
+	errorComponent?: (error: Error) => Node;
+	searchParams?: SearchParamSchema<unknown>;
+	children?: Record<string, RouteConfigLike>;
+}
+/**
+* Phantom branded array that carries the route map type `T`.
+* The `__routes` property never exists at runtime — it is a type-level
+* marker used to thread the developer's literal route keys through
+* `createRouter`, `useRouter`, etc.
+*/
+type TypedRoutes<T extends Record<string, RouteConfigLike> = RouteDefinitionMap> = CompiledRoute[] & {
+	readonly __routes: T;
+};
+/**
+* Extract the route map type from `TypedRoutes<T>`.
+* If `T` is not a `TypedRoutes`, returns `T` as-is (passthrough).
+*
+* Usage: `useRouter<InferRouteMap<typeof routes>>()`
+*/
+type InferRouteMap<T> = T extends TypedRoutes<infer R> ? R : T;
 /** Internal compiled route. */
 interface CompiledRoute {
 	/** The original path pattern. */
@@ -100,7 +165,7 @@ type LoaderData<T> = T extends {
 * Define routes from a configuration map.
 * Returns an array of compiled routes preserving definition order.
 */
-declare function defineRoutes(map: RouteDefinitionMap): CompiledRoute[];
+declare function defineRoutes<const T extends Record<string, RouteConfigLike>>(map: T): TypedRoutes<T>;
 /**
 * A reactive signal that holds a value and notifies subscribers on change.
 */
@@ -123,16 +188,50 @@ interface ReadonlySignal<T> {
 	/** Read the current value without subscribing. */
 	peek(): T;
 }
-/** Props for the Link component. */
-interface LinkProps {
+/**
+* Unwraps a ReadonlySignal to its value type.
+* Used by signal APIs (like query()) to expose plain values in TypeScript
+* while the compiler auto-unwraps them at runtime.
+*
+* @example
+* type UnwrappedData = Unwrapped<ReadonlySignal<Task | undefined>>; // → Task | undefined
+*/
+type Unwrapped<T> = T extends ReadonlySignal<infer U> ? U : T;
+/**
+* Unwraps all signal properties of an object type.
+* Properties that are signals become their inner value type.
+* Non-signal properties and primitive types pass through unchanged.
+*
+* Used by `useContext` to present context values without the Signal wrapper.
+*
+* @example
+* type Settings = { theme: Signal<string>; setTheme: (t: string) => void };
+* type Unwrapped = UnwrapSignals<Settings>; // { theme: string; setTheme: (t: string) => void }
+*/
+type UnwrapSignals<T> = T extends object ? { [K in keyof T] : Unwrapped<T[K]> } : T;
+/**
+* Props for the Link component.
+*
+* Generic over the route map `T`. Defaults to `RouteDefinitionMap` (string
+* index signature) for backward compatibility — unparameterized `LinkProps`
+* accepts any string href.
+*/
+interface LinkProps<T extends Record<string, RouteConfigLike> = RouteDefinitionMap> {
 	/** The target URL path. */
-	href: string;
-	/** Text or content for the link. */
-	children: string;
+	href: RoutePaths<T>;
+	/** Text or content for the link. Thunk may return string or Text node. */
+	children: string | (() => string | Node);
 	/** Class applied when the link's href matches the current path. */
 	activeClass?: string;
 	/** Static class name for the anchor element. */
 	className?: string;
+	/** Prefetch strategy. 'hover' triggers server pre-fetch on mouseenter/focus. */
+	prefetch?: "hover";
+}
+/** Options for createLink(). */
+interface LinkFactoryOptions {
+	/** Callback fired when a link wants to prefetch its target URL. */
+	onPrefetch?: (url: string) => void;
 }
 /**
 * Create a Link component factory bound to the router's state.
@@ -141,14 +240,45 @@ interface LinkProps {
 * @param navigate - Navigation function from the router
 * @returns A Link component function
 */
-declare function createLink(currentPath: ReadonlySignal<string>, navigate: (url: string) => void): (props: LinkProps) => HTMLAnchorElement;
+declare function createLink(currentPath: ReadonlySignal<string>, navigate: (url: string) => void, factoryOptions?: LinkFactoryOptions): (props: LinkProps) => HTMLAnchorElement;
 /** Options for router.navigate(). */
 interface NavigateOptions {
 	/** Use history.replaceState instead of pushState. */
 	replace?: boolean;
 }
-/** The router instance returned by createRouter. */
-interface Router {
+/** Handle returned by prefetchNavData for cancellation. */
+interface PrefetchHandle {
+	abort: () => void;
+	/** Resolves when SSE stream completes (data or done event). */
+	done?: Promise<void>;
+	/** Resolves when the first SSE event of any type arrives. */
+	firstEvent?: Promise<void>;
+}
+/** Options for createRouter(). */
+interface RouterOptions {
+	/** Enable server-side navigation pre-fetch. When true, uses default timeout. */
+	serverNav?: boolean | {
+		timeout?: number;
+	};
+	/** @internal — injected for testing. Production uses the real module. */
+	_prefetchNavData?: (url: string, options?: {
+		timeout?: number;
+	}) => PrefetchHandle;
+}
+/**
+* The router instance returned by createRouter.
+*
+* Generic over the route map `T`. Defaults to `RouteDefinitionMap` (string
+* index signature) for backward compatibility — unparameterized `Router`
+* accepts any string in `navigate()`.
+*
+* Method syntax on `navigate`, `revalidate`, and `dispose` enables bivariant
+* parameter checking under `strictFunctionTypes`. This means `Router<T>` is
+* assignable to `Router` (the unparameterized default), which is required for
+* storing typed routers in the `RouterContext` without contravariance errors.
+* At call sites, TypeScript still enforces the `RoutePaths<T>` constraint.
+*/
+interface Router<T extends Record<string, RouteConfigLike> = RouteDefinitionMap> {
 	/** Current matched route (reactive signal). */
 	current: Signal<RouteMatch | null>;
 	/** Loader data from the current route's loaders (reactive signal). */
@@ -158,43 +288,86 @@ interface Router {
 	/** Parsed search params from the current route (reactive signal). */
 	searchParams: Signal<Record<string, unknown>>;
 	/** Navigate to a new URL path. */
-	navigate: (url: string, options?: NavigateOptions) => Promise<void>;
+	navigate(url: RoutePaths<T>, options?: NavigateOptions): Promise<void>;
 	/** Re-run all loaders for the current route. */
-	revalidate: () => Promise<void>;
+	revalidate(): Promise<void>;
 	/** Remove popstate listener and clean up the router. */
-	dispose: () => void;
+	dispose(): void;
 }
 /**
+* Convenience alias for a typed router.
+* `TypedRouter<T>` is identical to `Router<T>` — it exists for readability
+* when the generic parameter makes the intent clearer.
+*/
+type TypedRouter<T extends Record<string, RouteConfigLike> = RouteDefinitionMap> = Router<T>;
+/**
 * Create a router instance.
 *
 * @param routes - Compiled route list from defineRoutes()
 * @param initialUrl - The initial URL to match (optional; auto-detects from window.location or __SSR_URL__)
 * @returns Router instance with reactive state and navigation methods
 */
-declare function createRouter(routes: CompiledRoute[], initialUrl?: string): Router;
+declare function createRouter<T extends Record<string, RouteConfigLike> = RouteDefinitionMap>(routes: TypedRoutes<T>, initialUrl?: string, options?: RouterOptions): Router<T>;
+/**
+* Props for the JSX pattern of Context.Provider.
+*
+* `children` accepts both raw values (what TypeScript sees in JSX) and
+* thunks (what the compiler produces). At compile time the compiler wraps
+* JSX children in `() => ...`, but TypeScript checks the pre-compilation
+* source where children are plain elements.
+*/
+interface ProviderJsxProps<T> {
+	value: T;
+	children: (() => unknown) | unknown;
+}
 /** A context object created by `createContext`. */
 interface Context<T> {
-	/** Provide a value to all `useContext` calls within the scope. */
-	Provider: (value: T, fn: () => void) => void;
+	/** Provide a value via callback pattern. */
+	Provider(value: T, fn: () => void): void;
+	/** Provide a value via JSX pattern (single-arg object with children thunk). */
+	Provider(props: ProviderJsxProps<T>): HTMLElement;
 	/** @internal — current value stack */
 	_stack: T[];
 	/** @internal — default value */
 	_default: T | undefined;
 }
 /** Context value for the Outlet. */
-interface OutletContext {
-	/** The child component factory to render, or undefined if no child. */
-	childComponent: (() => Node) | undefined;
-	/** The nesting depth (for debugging/tracking). */
-	depth: number;
+interface OutletContextValue {
+	/** Reactive child component factory (may return async module). */
+	childComponent: Signal<(() => Node | Promise<{
+		default: () => Node;
+	}>) | undefined>;
+	/** Router instance for restoring context in async resolution. */
+	router: Router;
+}
+/** Shared context used by RouterView and Outlet. */
+declare const OutletContext: Context<OutletContextValue>;
+/**
+* Outlet component — renders the nested child route.
+*
+* Must be called inside a layout component rendered by RouterView.
+* Reads from OutletContext to determine which child to render.
+*/
+declare function Outlet(): Node;
+declare const RouterContext: Context<Router>;
+declare function useRouter<T extends Record<string, RouteConfigLike> = RouteDefinitionMap>(): UnwrapSignals<Router<T>>;
+declare function useParams<TPath extends string = string>(): ExtractParams<TPath>;
+interface RouterViewProps {
+	router: Router;
+	fallback?: () => Node;
 }
 /**
-* Create an Outlet component bound to a specific outlet context.
+* Renders the matched route's component inside a container div.
+*
+* Handles sync and async (lazy-loaded) components, stale resolution guards,
+* page cleanup on navigation, and RouterContext propagation.
 *
-* @param outletCtx - The context that holds the child component
-* @returns An Outlet component function
+* Uses __element() so the container is claimed from SSR during hydration.
+* On the first hydration render, children are already in the DOM — the
+* domEffect runs the component factory (to attach reactivity/event handlers)
+* but skips clearing the container.
 */
-declare function createOutlet(outletCtx: Context<OutletContext>): () => Node;
+declare function RouterView({ router, fallback }: RouterViewProps): HTMLElement;
 /**
 * Parse URLSearchParams into a typed object, optionally through a schema.
 *
@@ -211,4 +384,4 @@ declare function parseSearchParams<T = Record<string, string>>(urlParams: URLSea
 * @returns The current search params value
 */
 declare function useSearchParams<T>(searchSignal: ReadonlySignal<T>): T;
-export { useSearchParams, parseSearchParams, defineRoutes, createRouter, createOutlet, createLink, SearchParamSchema, Router, RouteMatch, RouteDefinitionMap, RouteConfig, OutletContext, NavigateOptions, MatchedRoute, LoaderData, LinkProps, ExtractParams, CompiledRoute };
+export { useSearchParams, useRouter, useParams, parseSearchParams, defineRoutes, createRouter, createLink, TypedRoutes, TypedRouter, SearchParamSchema, RouterViewProps, RouterView, RouterContext, Router, RoutePaths, RouteMatch, RouteDefinitionMap, RouteConfig, PathWithParams, OutletContextValue, OutletContext, Outlet, NavigateOptions, MatchedRoute, LoaderData, LinkProps, InferRouteMap, ExtractParams, CompiledRoute };

package/dist/router/public.js

@@ -1,21 +1,36 @@
 import {
+  Outlet,
+  OutletContext,
+  RouterContext,
+  RouterView,
   createLink,
-  createOutlet,
   parseSearchParams,
+  useParams,
+  useRouter,
   useSearchParams
-} from "../shared/chunk-bp3v6s9j.js";
+} from "../shared/chunk-0xcmwgdb.js";
+import"../shared/chunk-v3yyf79g.js";
 import {
   createRouter
-} from "../shared/chunk-xd9d7q5p.js";
+} from "../shared/chunk-ka5ked7n.js";
 import {
   defineRoutes
-} from "../shared/chunk-j8vzvne3.js";
-import"../shared/chunk-pgymxpn1.js";
+} from "../shared/chunk-9e92w0wt.js";
+import"../shared/chunk-jrtrk5z4.js";
+import"../shared/chunk-ryb49346.js";
+import"../shared/chunk-g4rch80a.js";
+import"../shared/chunk-hrd0mft1.js";
+import"../shared/chunk-prj7nm08.js";
 export {
   useSearchParams,
+  useRouter,
+  useParams,
   parseSearchParams,
   defineRoutes,
   createRouter,
-  createOutlet,
-  createLink
+  createLink,
+  RouterView,
+  RouterContext,
+  OutletContext,
+  Outlet
 };