@timber-js/app 0.1.0

package/dist/client/segment-context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Segment Context — provides layout segment position for useSelectedLayoutSegment hooks.
+ *
+ * Each layout in the segment tree is wrapped with a SegmentProvider that stores
+ * the URL segments from root to the current layout level. The hooks read this
+ * context to determine which child segments are active below the calling layout.
+ *
+ * The context value is intentionally minimal: just the segment path array and
+ * parallel route keys. No internal cache details are exposed.
+ *
+ * Design docs: design/19-client-navigation.md, design/14-ecosystem.md
+ */
+export interface SegmentContextValue {
+    /** URL segments from root to this layout (e.g. ['', 'dashboard', 'settings']) */
+    segments: string[];
+    /** Parallel route slot keys available at this layout level (e.g. ['sidebar', 'modal']) */
+    parallelRouteKeys: string[];
+}
+/** Read the segment context. Returns null if no provider is above this component. */
+export declare function useSegmentContext(): SegmentContextValue | null;
+interface SegmentProviderProps {
+    segments: string[];
+    parallelRouteKeys: string[];
+    children: React.ReactNode;
+}
+/**
+ * Wraps each layout to provide segment position context.
+ * Injected by rsc-entry.ts during element tree construction.
+ */
+export declare function SegmentProvider({ segments, parallelRouteKeys, children }: SegmentProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<SegmentContextValue | null>>;
+export {};
+//# sourceMappingURL=segment-context.d.ts.map

package/dist/client/segment-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-context.d.ts","sourceRoot":"","sources":["../../src/client/segment-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,0FAA0F;IAC1F,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAMD,qFAAqF;AACrF,wBAAgB,iBAAiB,IAAI,mBAAmB,GAAG,IAAI,CAE9D;AAID,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,EAAE,oBAAoB,uGAS9F"}

package/dist/client/ssr-data.d.ts

@@ -0,0 +1,64 @@
+/**
+ * SSR Data — per-request state for client hooks during server-side rendering.
+ *
+ * RSC and SSR are separate Vite module graphs (see design/18-build-system.md),
+ * so the RSC environment's request-context ALS is not visible to SSR modules.
+ * This module provides getter/setter functions that ssr-entry.ts uses to
+ * populate per-request data for React's render.
+ *
+ * Request isolation: On the server, ssr-entry.ts registers an ALS-backed
+ * provider via registerSsrDataProvider(). getSsrData() reads from the ALS
+ * store, ensuring correct per-request data even when Suspense boundaries
+ * resolve asynchronously across concurrent requests. The module-level
+ * setSsrData/clearSsrData functions are kept as a fallback for tests
+ * and environments without ALS.
+ *
+ * IMPORTANT: This module must NOT import node:async_hooks or any Node.js-only
+ * APIs, as it's imported by 'use client' hooks that are bundled for the browser.
+ * The ALS instance lives in ssr-entry.ts (server-only); this module only holds
+ * a reference to the provider function.
+ */
+export interface SsrData {
+    /** The request's URL pathname (e.g. '/dashboard/settings') */
+    pathname: string;
+    /** The request's search params as a plain record */
+    searchParams: Record<string, string>;
+    /** The request's cookies as name→value pairs */
+    cookies: Map<string, string>;
+    /** The request's route params (e.g. { id: '123' }) */
+    params: Record<string, string | string[]>;
+}
+/**
+ * Register an ALS-backed SSR data provider. Called once at module load
+ * by ssr-entry.ts to wire up per-request data via AsyncLocalStorage.
+ *
+ * When registered, getSsrData() reads from the provider (ALS store)
+ * instead of module-level state, ensuring correct isolation for
+ * concurrent requests with streaming Suspense.
+ */
+export declare function registerSsrDataProvider(provider: () => SsrData | undefined): void;
+/**
+ * Set the SSR data for the current request via module-level state.
+ *
+ * In production, ssr-entry.ts uses ALS (runWithSsrData) instead.
+ * This function is retained for tests and as a fallback.
+ */
+export declare function setSsrData(data: SsrData): void;
+/**
+ * Clear the SSR data after rendering completes.
+ *
+ * In production, ALS scope handles cleanup automatically.
+ * This function is retained for tests and as a fallback.
+ */
+export declare function clearSsrData(): void;
+/**
+ * Read the current request's SSR data. Returns undefined when called
+ * outside an SSR render (i.e. on the client after hydration).
+ *
+ * Prefers the ALS-backed provider when registered (server-side),
+ * falling back to module-level state (tests, legacy).
+ *
+ * Used by client hooks' server snapshot functions.
+ */
+export declare function getSsrData(): SsrData | undefined;
+//# sourceMappingURL=ssr-data.d.ts.map

package/dist/client/ssr-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-data.d.ts","sourceRoot":"","sources":["../../src/client/ssr-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,MAAM,WAAW,OAAO;IACtB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,gDAAgD;IAChD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;CAC3C;AAUD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,OAAO,GAAG,SAAS,GAAG,IAAI,CAEjF;AAQD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,IAAI,OAAO,GAAG,SAAS,CAKhD"}

package/dist/client/types.d.ts

@@ -0,0 +1,5 @@
+export interface RenderErrorDigest<Code extends string = string, Data = unknown> {
+    code: Code;
+    data: Data;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/client/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,GAAG,OAAO;IAC7E,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;CACZ"}

package/dist/client/unload-guard.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Page unload detection — suppresses spurious errors during page refresh/navigation.
+ *
+ * When the user refreshes the page or navigates away while React is still
+ * streaming Suspense content, the aborted connection causes streaming errors.
+ * These are not application errors — they're a side effect of the browser
+ * tearing down the connection. This module tracks whether the page is being
+ * unloaded so error boundaries and error handlers can suppress abort-related
+ * errors during the unload window.
+ *
+ * See design/10-error-handling.md §"Known limitation: deny() inside Suspense and hydration"
+ */
+/**
+ * Returns true if the page is currently being unloaded (user refreshed
+ * or navigated away). Error boundaries should suppress errors in this state.
+ */
+export declare function isPageUnloading(): boolean;
+//# sourceMappingURL=unload-guard.d.ts.map

package/dist/client/unload-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unload-guard.d.ts","sourceRoot":"","sources":["../../src/client/unload-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAgBH;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC"}

package/dist/client/use-cookie.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useCookie — reactive client-side cookie hook.
+ *
+ * Uses useSyncExternalStore for SSR-safe, reactive cookie access.
+ * All components reading the same cookie name re-render on change.
+ * No cross-tab sync (intentional — see design/29-cookies.md).
+ *
+ * See design/29-cookies.md §"useCookie(name) Hook"
+ */
+export interface ClientCookieOptions {
+    /** URL path scope. Default: '/'. */
+    path?: string;
+    /** Domain scope. Default: omitted (current domain). */
+    domain?: string;
+    /** Max age in seconds. */
+    maxAge?: number;
+    /** Expiration date. */
+    expires?: Date;
+    /** Cross-site policy. Default: 'lax'. */
+    sameSite?: 'strict' | 'lax' | 'none';
+    /** Only send over HTTPS. Default: true in production. */
+    secure?: boolean;
+}
+export type CookieSetter = (value: string, options?: ClientCookieOptions) => void;
+/**
+ * Reactive hook for reading/writing a client-side cookie.
+ *
+ * Returns `[value, setCookie, deleteCookie]`:
+ * - `value`: current cookie value (string | undefined)
+ * - `setCookie`: sets the cookie and triggers re-renders
+ * - `deleteCookie`: deletes the cookie and triggers re-renders
+ *
+ * @param name - Cookie name.
+ * @param defaultOptions - Default options for setCookie calls.
+ */
+export declare function useCookie(name: string, defaultOptions?: ClientCookieOptions): [value: string | undefined, setCookie: CookieSetter, deleteCookie: () => void];
+//# sourceMappingURL=use-cookie.d.ts.map

package/dist/client/use-cookie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cookie.d.ts","sourceRoot":"","sources":["../../src/client/use-cookie.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,MAAM,WAAW,mBAAmB;IAClC,oCAAoC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,yCAAyC;IACzC,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IACrC,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,IAAI,CAAC;AA0ClF;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,mBAAmB,GACnC,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC,CAmChF"}

package/dist/client/use-link-status.d.ts

@@ -0,0 +1,35 @@
+export interface LinkStatus {
+    pending: boolean;
+}
+/**
+ * React context provided by <Link>. Holds the pending status
+ * for that specific link's navigation.
+ */
+export declare const LinkStatusContext: import("react").Context<LinkStatus>;
+/**
+ * Returns `{ pending: true }` while the nearest parent `<Link>` component's
+ * navigation is in flight. Must be used inside a `<Link>` component's children.
+ *
+ * Unlike `useNavigationPending()` which is global, this hook is scoped to
+ * the nearest parent `<Link>` — only the link the user clicked shows pending.
+ *
+ * ```tsx
+ * 'use client'
+ * import { Link, useLinkStatus } from '@timber/app/client'
+ *
+ * function Hint() {
+ *   const { pending } = useLinkStatus()
+ *   return <span className={pending ? 'opacity-50' : ''} />
+ * }
+ *
+ * export function NavLink({ href, children }) {
+ *   return (
+ *     <Link href={href}>
+ *       {children} <Hint />
+ *     </Link>
+ *   )
+ * }
+ * ```
+ */
+export declare function useLinkStatus(): LinkStatus;
+//# sourceMappingURL=use-link-status.d.ts.map

package/dist/client/use-link-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-link-status.d.ts","sourceRoot":"","sources":["../../src/client/use-link-status.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,qCAAgD,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAE1C"}

package/dist/client/use-navigation-pending.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns true while an RSC navigation is in flight.
+ *
+ * The pending state is true from the moment the RSC fetch starts until
+ * React reconciliation completes. This includes the fetch itself,
+ * RSC stream parsing, and React tree reconciliation.
+ *
+ * It does NOT include Suspense streaming after the shell — only the
+ * initial shell reconciliation.
+ *
+ * ```tsx
+ * 'use client'
+ * import { useNavigationPending } from '@timber/app/client'
+ *
+ * export function NavBar() {
+ *   const isPending = useNavigationPending()
+ *   return (
+ *     <nav className={isPending ? 'opacity-50' : ''}>
+ *       <Link href="/dashboard">Dashboard</Link>
+ *     </nav>
+ *   )
+ * }
+ * ```
+ */
+export declare function useNavigationPending(): boolean;
+//# sourceMappingURL=use-navigation-pending.d.ts.map

package/dist/client/use-navigation-pending.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-navigation-pending.d.ts","sourceRoot":"","sources":["../../src/client/use-navigation-pending.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAgB9C"}

package/dist/client/use-params.d.ts

@@ -0,0 +1,50 @@
+/**
+ * useParams() — client-side hook for accessing route params.
+ *
+ * Returns the dynamic route parameters for the current URL.
+ * When called with a route pattern argument, TypeScript narrows
+ * the return type to the exact params shape for that route.
+ *
+ * Two layers of type narrowing work together:
+ * 1. The generic overload here uses the Routes interface directly —
+ *    `useParams<R>()` returns `Routes[R]['params']`.
+ * 2. Build-time codegen generates per-route string-literal overloads
+ *    in the .d.ts file for IDE autocomplete (see routing/codegen.ts).
+ *
+ * When the Routes interface is empty (no codegen yet), the generic
+ * overload has `keyof Routes = never`, so only the fallback matches.
+ *
+ * During SSR, params are read from the ALS-backed SSR data context
+ * (populated by ssr-entry.ts) to ensure correct per-request isolation
+ * across concurrent requests with streaming Suspense.
+ *
+ * Design doc: design/09-typescript.md §"Typed Routes"
+ */
+import type { Routes } from '#/index.js';
+/**
+ * Set the current route params. Called by the framework internals
+ * during navigation — not intended for direct use by app code.
+ *
+ * On the client, the segment router calls this on each navigation.
+ * During SSR, params are also available via getSsrData().params
+ * (ALS-backed), but setCurrentParams is still called for the
+ * module-level fallback path.
+ */
+export declare function setCurrentParams(params: Record<string, string | string[]>): void;
+/**
+ * Read the current route's dynamic params.
+ *
+ * The optional `_route` argument exists only for TypeScript narrowing —
+ * it does not affect the runtime return value.
+ *
+ * During SSR, reads from the ALS-backed SSR data context to ensure
+ * per-request isolation. On the client, reads from module-level state
+ * (set by the segment router on each navigation).
+ *
+ * @overload Typed — when a known route path is passed, returns the
+ *   exact params shape from the generated Routes interface.
+ * @overload Fallback — returns the generic params record.
+ */
+export declare function useParams<R extends keyof Routes>(route: R): Routes[R]['params'];
+export declare function useParams(route?: string): Record<string, string | string[]>;
+//# sourceMappingURL=use-params.d.ts.map

package/dist/client/use-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-params.d.ts","sourceRoot":"","sources":["../../src/client/use-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AASzC;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAEhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AACjF,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC"}

package/dist/client/use-pathname.d.ts

@@ -0,0 +1,20 @@
+/**
+ * usePathname() — client-side hook for reading the current pathname.
+ *
+ * Returns the pathname portion of the current URL (e.g. '/dashboard/settings').
+ * Updates when client-side navigation changes the URL.
+ *
+ * This is a thin wrapper over window.location.pathname, provided for
+ * Next.js API compatibility (libraries like nuqs import usePathname
+ * from next/navigation).
+ *
+ * During SSR, reads the request pathname from the SSR ALS context
+ * (populated by ssr-entry.ts) instead of window.location.
+ */
+/**
+ * Read the current URL pathname.
+ *
+ * Compatible with Next.js's `usePathname()` from `next/navigation`.
+ */
+export declare function usePathname(): string;
+//# sourceMappingURL=use-pathname.d.ts.map

package/dist/client/use-pathname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pathname.d.ts","sourceRoot":"","sources":["../../src/client/use-pathname.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAuBH;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC"}

package/dist/client/use-query-states.d.ts

@@ -0,0 +1,36 @@
+/**
+ * useQueryStates — client-side hook for URL-synced search params.
+ *
+ * Delegates to nuqs for URL synchronization, batching, React 19 transitions,
+ * and throttled URL writes. Bridges timber's SearchParamCodec protocol to
+ * nuqs-compatible parsers.
+ *
+ * Design doc: design/23-search-params.md §"Codec Bridge"
+ */
+import type { SearchParamCodec, SearchParamsDefinition, SetParams, QueryStatesOptions } from '#/search-params/create.js';
+/**
+ * Read and write typed search params from/to the URL.
+ *
+ * Delegates to nuqs internally. The timber nuqs adapter (auto-injected in
+ * browser-entry.ts) handles RSC navigation on non-shallow updates.
+ *
+ * Usage:
+ * ```ts
+ * // Via a SearchParamsDefinition
+ * const [params, setParams] = definition.useQueryStates()
+ *
+ * // Standalone with inline codecs
+ * const [params, setParams] = useQueryStates({
+ *   page: fromSchema(z.coerce.number().int().min(1).default(1)),
+ * })
+ * ```
+ */
+export declare function useQueryStates<T extends Record<string, unknown>>(codecsOrRoute: {
+    [K in keyof T]: SearchParamCodec<T[K]>;
+} | string, _options?: QueryStatesOptions, urlKeys?: Readonly<Record<string, string>>): [T, SetParams<T>];
+/**
+ * Create a useQueryStates binding for a SearchParamsDefinition.
+ * This is used internally by SearchParamsDefinition.useQueryStates().
+ */
+export declare function bindUseQueryStates<T extends Record<string, unknown>>(definition: SearchParamsDefinition<T>): (options?: QueryStatesOptions) => [T, SetParams<T>];
+//# sourceMappingURL=use-query-states.d.ts.map

package/dist/client/use-query-states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-query-states.d.ts","sourceRoot":"","sources":["../../src/client/use-query-states.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,EACtB,SAAS,EACT,kBAAkB,EACnB,MAAM,2BAA2B,CAAC;AAoCnC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9D,aAAa,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,MAAM,EAClE,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACzC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CA0CnB;AAID;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,UAAU,EAAE,sBAAsB,CAAC,CAAC,CAAC,GACpC,CAAC,OAAO,CAAC,EAAE,kBAAkB,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAIrD"}

package/dist/client/use-router.d.ts

@@ -0,0 +1,39 @@
+/**
+ * useRouter() — client-side hook for programmatic navigation.
+ *
+ * Returns a router instance with push, replace, refresh, back, forward,
+ * and prefetch methods. Compatible with Next.js's `useRouter()` from
+ * `next/navigation` (App Router).
+ *
+ * This wraps timber's internal RouterInstance in the Next.js-compatible
+ * AppRouterInstance shape that ecosystem libraries expect.
+ */
+export interface AppRouterInstance {
+    /** Navigate to a URL, pushing a new history entry */
+    push(href: string, options?: {
+        scroll?: boolean;
+    }): void;
+    /** Navigate to a URL, replacing the current history entry */
+    replace(href: string, options?: {
+        scroll?: boolean;
+    }): void;
+    /** Refresh the current page (re-fetch RSC payload) */
+    refresh(): void;
+    /** Navigate back in history */
+    back(): void;
+    /** Navigate forward in history */
+    forward(): void;
+    /** Prefetch an RSC payload for a URL */
+    prefetch(href: string): void;
+}
+/**
+ * Get a router instance for programmatic navigation.
+ *
+ * Compatible with Next.js's `useRouter()` from `next/navigation`.
+ *
+ * Returns a no-op router during SSR or before the client router is bootstrapped,
+ * so components that call useRouter() at the function level (e.g. TransitionLink)
+ * do not crash during server-side rendering.
+ */
+export declare function useRouter(): AppRouterInstance;
+//# sourceMappingURL=use-router.d.ts.map

package/dist/client/use-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-router.d.ts","sourceRoot":"","sources":["../../src/client/use-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACzD,6DAA6D;IAC7D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5D,sDAAsD;IACtD,OAAO,IAAI,IAAI,CAAC;IAChB,+BAA+B;IAC/B,IAAI,IAAI,IAAI,CAAC;IACb,kCAAkC;IAClC,OAAO,IAAI,IAAI,CAAC;IAChB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAYD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,IAAI,iBAAiB,CA6B7C"}

package/dist/client/use-search-params.d.ts

@@ -0,0 +1,24 @@
+/**
+ * useSearchParams() — client-side hook for reading URL search params.
+ *
+ * Returns a read-only URLSearchParams instance reflecting the current
+ * URL's query string. Updates when client-side navigation changes the URL.
+ *
+ * This is a thin wrapper over window.location.search, provided for
+ * Next.js API compatibility (libraries like nuqs import useSearchParams
+ * from next/navigation).
+ *
+ * Unlike Next.js's ReadonlyURLSearchParams, this returns a standard
+ * URLSearchParams. Mutation methods (set, delete, append) work on the
+ * local copy but do NOT affect the URL — use the router or nuqs for that.
+ *
+ * During SSR, reads the request search params from the SSR ALS context
+ * (populated by ssr-entry.ts) instead of window.location.
+ */
+/**
+ * Read the current URL search params.
+ *
+ * Compatible with Next.js's `useSearchParams()` from `next/navigation`.
+ */
+export declare function useSearchParams(): URLSearchParams;
+//# sourceMappingURL=use-search-params.d.ts.map

package/dist/client/use-search-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-search-params.d.ts","sourceRoot":"","sources":["../../src/client/use-search-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AA8CH;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,eAAe,CAMjD"}

package/dist/client/use-selected-layout-segment.d.ts

@@ -0,0 +1,68 @@
+/**
+ * useSelectedLayoutSegment / useSelectedLayoutSegments — client-side hooks
+ * for reading the active segment(s) below the current layout.
+ *
+ * These hooks are used by navigation UIs to highlight active sections.
+ * They match Next.js's API from next/navigation.
+ *
+ * How they work:
+ * 1. Each layout is wrapped with a SegmentProvider that records its depth
+ *    (the URL segments from root to that layout level).
+ * 2. The hooks read the current URL pathname via usePathname().
+ * 3. They compare the layout's segment depth against the full URL segments
+ *    to determine which child segments are "selected" below.
+ *
+ * Example: For URL "/dashboard/settings/profile"
+ * - Root layout (depth 0, segments: ['']): selected segment = "dashboard"
+ * - Dashboard layout (depth 1, segments: ['', 'dashboard']): selected = "settings"
+ * - Settings layout (depth 2, segments: ['', 'dashboard', 'settings']): selected = "profile"
+ *
+ * Design docs: design/19-client-navigation.md, design/14-ecosystem.md
+ */
+/**
+ * Split a pathname into URL segments.
+ * "/" → [""]
+ * "/dashboard" → ["", "dashboard"]
+ * "/dashboard/settings" → ["", "dashboard", "settings"]
+ */
+export declare function pathnameToSegments(pathname: string): string[];
+/**
+ * Pure function: compute the selected child segment given a layout's segment
+ * depth and the current URL pathname.
+ *
+ * @param contextSegments — segments from root to the calling layout, or null if no context
+ * @param pathname — current URL pathname
+ * @returns the active child segment one level below, or null if at the leaf
+ */
+export declare function getSelectedSegment(contextSegments: string[] | null, pathname: string): string | null;
+/**
+ * Pure function: compute all selected segments below a layout's depth.
+ *
+ * @param contextSegments — segments from root to the calling layout, or null if no context
+ * @param pathname — current URL pathname
+ * @returns all active segments below the layout
+ */
+export declare function getSelectedSegments(contextSegments: string[] | null, pathname: string): string[];
+/**
+ * Returns the active child segment one level below the layout where this
+ * hook is called. Returns `null` if the layout is the leaf (no child segment).
+ *
+ * Compatible with Next.js's `useSelectedLayoutSegment()` from `next/navigation`.
+ *
+ * @param parallelRouteKey — Optional parallel route key. Currently unused
+ *   (parallel route segment tracking is not yet implemented). Accepted for
+ *   API compatibility with Next.js.
+ */
+export declare function useSelectedLayoutSegment(parallelRouteKey?: string): string | null;
+/**
+ * Returns all active segments below the layout where this hook is called.
+ * Returns an empty array if the layout is the leaf (no child segments).
+ *
+ * Compatible with Next.js's `useSelectedLayoutSegments()` from `next/navigation`.
+ *
+ * @param parallelRouteKey — Optional parallel route key. Currently unused
+ *   (parallel route segment tracking is not yet implemented). Accepted for
+ *   API compatibility with Next.js.
+ */
+export declare function useSelectedLayoutSegments(parallelRouteKey?: string): string[];
+//# sourceMappingURL=use-selected-layout-segment.d.ts.map

package/dist/client/use-selected-layout-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-selected-layout-segment.d.ts","sourceRoot":"","sources":["../../src/client/use-selected-layout-segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,EAChC,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CASf;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAShG;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKjF;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAK7E"}

package/dist/content/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @timber/app/content — Public API for content collections.
+ *
+ * Re-exports from content-collections and provides timber-specific utilities.
+ * Users can import directly from 'content-collections' for generated types,
+ * or use this module for the re-exports.
+ *
+ * Design doc: 20-content-collections.md §"Querying Collections"
+ */
+export { defineCollection, defineConfig } from '@content-collections/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/content/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/content/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/content/index.js

@@ -0,0 +1,2 @@
+import { defineCollection, defineConfig } from "@content-collections/core";
+export { defineCollection, defineConfig };

package/dist/cookies/define-cookie.d.ts

@@ -0,0 +1,61 @@
+/**
+ * defineCookie — typed cookie definitions.
+ *
+ * Bundles name + codec + options into a reusable CookieDefinition<T>
+ * with .get(), .set(), .delete() server methods and a .useCookie() client hook.
+ *
+ * Reuses the SearchParamCodec protocol via fromSchema() bridge.
+ * Validation on read returns the codec default (never throws).
+ *
+ * See design/29-cookies.md §"Typed Cookies with Schema Validation"
+ */
+import type { CookieOptions } from '#/server/request-context.js';
+/**
+ * A codec that converts between string cookie values and typed values.
+ * Intentionally identical to SearchParamCodec<T>.
+ */
+export interface CookieCodec<T> {
+    parse(value: string | string[] | undefined): T;
+    serialize(value: T): string | null;
+}
+/** Options for defineCookie: codec + CookieOptions merged. */
+export interface DefineCookieOptions<T> extends Omit<CookieOptions, 'signed'> {
+    /** Codec for parsing/serializing the cookie value. */
+    codec: CookieCodec<T>;
+    /** Sign the cookie with HMAC-SHA256. */
+    signed?: boolean;
+}
+/** A fully typed cookie definition with server and client methods. */
+export interface CookieDefinition<T> {
+    /** The cookie name. */
+    readonly name: string;
+    /** The resolved cookie options (without codec). */
+    readonly options: CookieOptions;
+    /** The codec used for parsing/serializing. */
+    readonly codec: CookieCodec<T>;
+    /** Server: read the typed value from the current request. */
+    get(): T;
+    /** Server: set the typed value on the response. */
+    set(value: T): void;
+    /** Server: delete the cookie. */
+    delete(): void;
+    /** Client: React hook for reading/writing this cookie. Returns [value, setter, deleter]. */
+    useCookie(): [T, (value: T) => void, () => void];
+}
+/**
+ * Define a typed cookie.
+ *
+ * ```ts
+ * import { defineCookie } from '@timber/app/cookies';
+ * import { fromSchema } from '@timber/app/search-params';
+ * import { z } from 'zod/v4';
+ *
+ * export const themeCookie = defineCookie('theme', {
+ *   codec: fromSchema(z.enum(['light', 'dark', 'system']).default('system')),
+ *   httpOnly: false,
+ *   maxAge: 60 * 60 * 24 * 365,
+ * });
+ * ```
+ */
+export declare function defineCookie<T>(name: string, options: DefineCookieOptions<T>): CookieDefinition<T>;
+//# sourceMappingURL=define-cookie.d.ts.map

package/dist/cookies/define-cookie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-cookie.d.ts","sourceRoot":"","sources":["../../src/cookies/define-cookie.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAMjE;;;GAGG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,GAAG,CAAC,CAAC;IAC/C,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC;IAC3E,sDAAsD;IACtD,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACtB,wCAAwC;IACxC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAE/B,6DAA6D;IAC7D,GAAG,IAAI,CAAC,CAAC;IACT,mDAAmD;IACnD,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB,iCAAiC;IACjC,MAAM,IAAI,IAAI,CAAC;IAEf,4FAA4F;IAC5F,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC;CAClD;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,gBAAgB,CAAC,CAAC,CAAC,CA4DrB"}

package/dist/cookies/index.d.ts

@@ -0,0 +1,3 @@
+export { defineCookie } from './define-cookie.js';
+export type { CookieDefinition, CookieCodec, DefineCookieOptions, } from './define-cookie.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cookies/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cookies/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,mBAAmB,GACpB,MAAM,oBAAoB,CAAC"}