@timber-js/app 0.2.0-alpha.16 → 0.2.0-alpha.160

package/dist/client/stale-reload.d.ts

@@ -1,44 +0,0 @@
-/**
- * Stale Client Reference Reload
- *
- * When a new deployment ships updated bundles, clients running stale
- * JavaScript may encounter "Could not find the module" errors during
- * RSC Flight stream decoding. This happens because the RSC payload
- * references module IDs from the new bundle that don't exist in the
- * old client bundle.
- *
- * This module detects these specific errors and triggers a full page
- * reload so the browser fetches the new bundle. A sessionStorage flag
- * guards against infinite reload loops.
- *
- * See: LOCAL-332
- */
-/**
- * Check if an error is a stale client reference error from React's
- * Flight client. These errors have the message pattern:
- *   "Could not find the module \"<id>\""
- *
- * This is thrown by react-server-dom-webpack's client when the RSC
- * payload references a module ID that doesn't exist in the client's
- * module map — typically because the server has been redeployed with
- * new bundle hashes while the client is still running old JavaScript.
- */
-export declare function isStaleClientReference(error: unknown): boolean;
-/**
- * Trigger a full page reload to pick up new bundles.
- *
- * Sets a sessionStorage flag before reloading. If the flag is already
- * set (meaning we already reloaded once for this reason), we don't
- * reload again — this prevents infinite reload loops if the error
- * persists after reload (e.g., a genuine bug rather than a stale bundle).
- *
- * @returns true if a reload was triggered, false if suppressed (loop guard)
- */
-export declare function triggerStaleReload(): boolean;
-/**
- * Clear the stale reload flag. Called on successful bootstrap to reset
- * the loop guard — if the page loaded successfully, the next stale
- * reference error should trigger a fresh reload attempt.
- */
-export declare function clearStaleReloadFlag(): void;
-//# sourceMappingURL=stale-reload.d.ts.map

package/dist/client/stale-reload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stale-reload.d.ts","sourceRoot":"","sources":["../../src/client/stale-reload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CA6B5C;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAM3C"}

package/dist/client/transition-root.d.ts

@@ -1,74 +0,0 @@
-/**
- * TransitionRoot — Wrapper component for transition-based rendering.
- *
- * Solves the "new boundary has no old content" problem for client-side
- * navigation. When React renders a completely new Suspense boundary via
- * root.render(), it shows the fallback immediately — root.render() is
- * always an urgent update regardless of startTransition.
- *
- * TransitionRoot holds the current element in React state. Navigation
- * updates call startTransition(() => setState(newElement)), which IS
- * a transition update. React keeps the old committed tree visible while
- * any new Suspense boundaries in the transition resolve.
- *
- * Also manages `pendingUrl` as React state with an urgent/transition split:
- * - Navigation START: `setPendingUrl(url)` is an urgent update — React
- *   commits it before the next paint, showing the spinner immediately.
- * - Navigation END: `setPendingUrl(null)` is inside `startTransition`
- *   alongside `setElement(newTree)` — both commit atomically, so the
- *   spinner disappears in the same frame as the new content appears.
- *
- * See design/05-streaming.md §"deferSuspenseFor"
- * See design/19-client-navigation.md §"NavigationContext"
- */
-import { type ReactNode } from 'react';
-import { type TopLoaderConfig } from './top-loader.js';
-/**
- * Root wrapper component that enables transition-based rendering.
- *
- * Renders PendingNavigationProvider around children for the pending URL
- * context. The DOM tree matches the server-rendered HTML during hydration
- * (the provider renders no extra DOM elements).
- *
- * Usage in browser-entry.ts:
- *   const rootEl = createElement(TransitionRoot, { initial: wrapped });
- *   reactRoot = hydrateRoot(document, rootEl);
- *
- * Subsequent navigations:
- *   navigateTransition(url, async () => { fetch; return wrappedElement; });
- *
- * Non-navigation renders:
- *   transitionRender(newWrappedElement);
- */
-export declare function TransitionRoot({ initial, topLoaderConfig, }: {
-    initial: ReactNode;
-    topLoaderConfig?: TopLoaderConfig;
-}): ReactNode;
-/**
- * Trigger a transition render for non-navigation updates.
- * React keeps the old committed tree visible while any new Suspense
- * boundaries in the update resolve.
- *
- * Used for: applyRevalidation, popstate replay with cached payload.
- */
-export declare function transitionRender(element: ReactNode): void;
-/**
- * Run a full navigation inside a React transition with optimistic pending URL.
- *
- * The `perform` callback runs inside `startTransition` — it should fetch the
- * RSC payload, update router state, and return the wrapped React element.
- * The pending URL shows immediately (useOptimistic urgent update) and reverts
- * to null when the transition commits (atomic with the new tree).
- *
- * Returns a Promise that resolves when the async work completes (note: the
- * React transition may not have committed yet, but all state updates are done).
- *
- * Used for: navigate(), refresh(), popstate with fetch.
- */
-export declare function navigateTransition(pendingUrl: string, perform: () => Promise<ReactNode>): Promise<void>;
-/**
- * Check if the TransitionRoot is mounted and ready for renders.
- * Used by browser-entry.ts to guard against renders before hydration.
- */
-export declare function isTransitionRootReady(): boolean;
-//# sourceMappingURL=transition-root.d.ts.map

package/dist/client/transition-root.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transition-root.d.ts","sourceRoot":"","sources":["../../src/client/transition-root.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEzF,OAAO,EAAa,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAqBlE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,eAAe,GAChB,EAAE;IACD,OAAO,EAAE,SAAS,CAAC;IACnB,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,GAAG,SAAS,CAgDZ;AAID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAIzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C"}

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

@@ -1,26 +0,0 @@
-/**
- * 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-js/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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-params.d.ts","sourceRoot":"","sources":["../../src/client/use-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AASzC;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAG1D;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAE/D;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAEhF;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAI5C;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;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/plugins/cache-transform.d.ts

@@ -1,36 +0,0 @@
-import type { Plugin } from 'vite';
-/**
- * Parse a cacheLife duration string to seconds.
- * Supports: '30s', '5m', '1h', '2d', '1w', or a plain number (seconds).
- */
-export declare function parseCacheLife(value: string | number): number;
-export interface CacheTransformWarning {
-    message: string;
-    functionName: string;
-}
-interface TransformResult {
-    code: string;
-    map?: null;
-    warnings?: CacheTransformWarning[];
-}
-/**
- * Check if a 'use cache' function in a dynamic route page/layout receives
- * Promise-typed params, which are not serializable as cache keys.
- */
-export declare function detectPromiseParamsWarning(declaration: string, functionName: string, fileId: string): CacheTransformWarning | null;
-/**
- * Transform source code containing 'use cache' directives into
- * registerCachedFunction() calls.
- *
- * Returns null if no transformations were made.
- */
-export declare function transformUseCache(code: string, fileId: string): TransformResult | null;
-/**
- * Vite plugin: timber-cache
- *
- * Transforms 'use cache' directives into registerCachedFunction() calls.
- * Only runs in the RSC environment.
- */
-export declare function cacheTransformPlugin(): Plugin;
-export {};
-//# sourceMappingURL=cache-transform.d.ts.map

package/dist/plugins/cache-transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-transform.d.ts","sourceRoot":"","sources":["../../src/plugins/cache-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAc7D;AAKD,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAC;CACpC;AAmDD;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,qBAAqB,GAAG,IAAI,CAW9B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAuDtF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAsB7C"}

package/dist/plugins/dev-error-overlay.d.ts

@@ -1,60 +0,0 @@
-/**
- * Dev error overlay — formats and sends errors to Vite's browser overlay and stderr.
- *
- * Integrates with Vite's built-in error overlay (`server.ssrFixStacktrace` +
- * `server.hot.send`) rather than implementing a custom overlay.
- *
- * Design doc: 21-dev-server.md §"Error Overlay"
- */
-import type { ViteDevServer } from 'vite';
-/** The phase of the pipeline where the error occurred. */
-export type ErrorPhase = 'module-transform' | 'proxy' | 'middleware' | 'access' | 'render' | 'handler';
-export type FrameType = 'app' | 'framework' | 'internal';
-/**
- * Classify a stack frame line by origin.
- *
- * - 'app': user application code (in project root, not node_modules)
- * - 'framework': timber-app internal code
- * - 'internal': node_modules, Node.js internals
- */
-export declare function classifyFrame(frameLine: string, projectRoot: string): FrameType;
-/**
- * Extract the React component stack from an error, if present.
- * React attaches this as `componentStack` during renderToReadableStream errors.
- */
-export declare function extractComponentStack(error: unknown): string | null;
-interface SourceLocation {
-    file: string;
-    line: number;
-    column: number;
-}
-/**
- * Parse the first application frame from a stack trace.
- * Returns file/line/column for the overlay's `loc` field.
- */
-export declare function parseFirstAppFrame(stack: string, projectRoot: string): SourceLocation | null;
-/**
- * Classify the error phase by inspecting the error's stack trace.
- * Falls back to 'render' if no specific phase can be determined.
- */
-export declare function classifyErrorPhase(error: Error, projectRoot: string): ErrorPhase;
-/**
- * Format an error for terminal output.
- *
- * - Red for the error message and phase label
- * - Dim for framework-internal frames
- * - Normal for application frames
- * - Separate section for component stack (if present)
- */
-export declare function formatTerminalError(error: Error, phase: ErrorPhase, projectRoot: string): string;
-/**
- * Send an error to Vite's browser overlay and log it to stderr.
- *
- * Uses `server.ssrFixStacktrace()` to map stack traces back to source,
- * then sends the error via `server.hot.send()` for the browser overlay.
- *
- * The dev server remains running — errors are handled, not fatal.
- */
-export declare function sendErrorToOverlay(server: ViteDevServer, error: Error, phase: ErrorPhase, projectRoot: string): void;
-export {};
-//# sourceMappingURL=dev-error-overlay.d.ts.map

package/dist/plugins/dev-error-overlay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-error-overlay.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-error-overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAI1C,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAClB,kBAAkB,GAClB,OAAO,GACP,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,CAAC;AAcd,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,CAU/E;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAUnE;AAID,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAqB5F;AAID;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAehF;AAUD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAiChG;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,MAAM,GAClB,IAAI,CAgCN"}

package/dist/plugins/dev-logs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-logs.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-logs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIhD,iDAAiD;AACjD,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAIzE,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AA2ID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAsBnD;AAoDD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAiBzD"}

package/dist/plugins/dynamic-transform.d.ts

@@ -1,72 +0,0 @@
-/**
- * timber-dynamic-transform — Vite sub-plugin for 'use dynamic' directive.
- *
- * Detects `'use dynamic'` directives in server component function bodies
- * and transforms them into `markDynamic()` runtime calls. The directive
- * declares a dynamic boundary — the component and its subtree opt out of
- * the pre-rendered shell and render per-request.
- *
- * - In `output: 'static'` mode, `'use dynamic'` is a build error.
- * - In standard SSR routes (no prerender.ts), the directive is a no-op
- *   (everything is already per-request), but the transform still runs
- *   so the runtime can skip unnecessary work.
- *
- * Design doc: design/15-future-prerendering.md §"'use dynamic'"
- */
-import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
-/**
- * Quick check: does this source file contain 'use dynamic' anywhere?
- * Used as a fast bail-out before doing expensive AST parsing.
- */
-export declare function containsUseDynamic(code: string): boolean;
-interface TransformResult {
-    code: string;
-    map?: null;
-}
-/**
- * Find function declarations/expressions containing 'use dynamic' and
- * transform them into markDynamic() calls.
- *
- * Input:
- * ```tsx
- * export default async function AddToCartButton({ productId }) {
- *   'use dynamic'
- *   const user = await getUser()
- *   return <button>Add to cart</button>
- * }
- * ```
- *
- * Output:
- * ```tsx
- * import { markDynamic as __markDynamic } from '@timber-js/app/runtime';
- * export default async function AddToCartButton({ productId }) {
- *   __markDynamic();
- *   const user = await getUser()
- *   return <button>Add to cart</button>
- * }
- * ```
- *
- * The markDynamic() call registers the component boundary as dynamic
- * at render time. The pre-render pass uses this to know which subtrees
- * to skip and leave as holes for per-request rendering.
- */
-export declare function transformUseDynamic(code: string): TransformResult | null;
-/**
- * In `output: 'static'` mode, `'use dynamic'` is a build error.
- * Static mode renders everything at build time — there is no per-request
- * rendering to opt into.
- */
-export declare function validateNoDynamicInStaticMode(code: string): {
-    message: string;
-    line?: number;
-} | null;
-/**
- * Create the timber-dynamic-transform Vite plugin.
- *
- * In server mode: transforms 'use dynamic' into markDynamic() calls.
- * In static mode: rejects 'use dynamic' as a build error.
- */
-export declare function timberDynamicTransform(ctx: PluginContext): Plugin;
-export {};
-//# sourceMappingURL=dynamic-transform.d.ts.map

package/dist/plugins/dynamic-transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dynamic-transform.d.ts","sourceRoot":"","sources":["../../src/plugins/dynamic-transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAMD,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAoBxE;AAMD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,GACX;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAa3C;AAMD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAkCjE"}

package/dist/plugins/server-action-exports.d.ts

@@ -1,26 +0,0 @@
-import type { Plugin } from 'vite';
-/**
- * Rewrite 'use server' module exports to bypass RSC plugin AST validation.
- *
- * The RSC plugin's client/SSR proxy transform (transformProxyExport) requires
- * all `export const` initializers to be `async ArrowFunctionExpression`. But
- * `createActionClient().action()` and `validated()` return async functions via
- * CallExpressions — valid at runtime but rejected by the static AST check.
- *
- * This plugin rewrites non-function-expression exports from:
- *
- *   export const foo = someCall();
- *
- * to:
- *
- *   const foo = someCall();
- *   export { foo };
- *
- * The `export { name }` form bypasses the RSC plugin's validation without
- * changing runtime semantics. Function expression exports (async arrows,
- * async function expressions) are left untouched.
- *
- * See design/08-forms-and-actions.md §"Middleware for Server Actions"
- */
-export declare function timberServerActionExports(): Plugin;
-//# sourceMappingURL=server-action-exports.d.ts.map

package/dist/plugins/server-action-exports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server-action-exports.d.ts","sourceRoot":"","sources":["../../src/plugins/server-action-exports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAOnC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAelD"}

package/dist/routing/status-file-lint.d.ts

@@ -1,33 +0,0 @@
-/**
- * Lint status files and error.tsx for missing 'use client' directive.
- *
- * Status files (error.tsx, 404.tsx, 4xx.tsx, 5xx.tsx, NNN.tsx) and legacy
- * compat files (not-found.tsx, forbidden.tsx, unauthorized.tsx) are passed
- * as fallbackComponent to TimberErrorBoundary — a 'use client' component.
- * RSC forbids passing server component functions as props to client
- * components, causing a hard-to-debug runtime error.
- *
- * This module provides a build/dev-time check that warns when these files
- * are missing the 'use client' directive.
- *
- * See design/10-error-handling.md §"Status-Code Files".
- */
-import type { RouteTree } from './types.js';
-export interface StatusFileLintWarning {
-    filePath: string;
-    fileType: string;
-}
-/**
- * Walk the route tree and check all status files and error files for
- * the 'use client' directive. Returns an array of warnings for files
- * that are missing it.
- *
- * MDX and JSON status files are excluded — MDX files are server components
- * by design, and JSON files are data, not components.
- */
-export declare function lintStatusFileDirectives(tree: RouteTree): StatusFileLintWarning[];
-/**
- * Format warnings into human-readable console output.
- */
-export declare function formatStatusFileLintWarnings(warnings: StatusFileLintWarning[]): string;
-//# sourceMappingURL=status-file-lint.d.ts.map

package/dist/routing/status-file-lint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"status-file-lint.d.ts","sourceRoot":"","sources":["../../src/routing/status-file-lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAMzD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,SAAS,GAAG,qBAAqB,EAAE,CAIjF;AAoDD;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qBAAqB,EAAE,GAAG,MAAM,CAiBtF"}

package/dist/search-params/analyze.d.ts

@@ -1,54 +0,0 @@
-/**
- * Static analyzability checker for search-params.ts files.
- *
- * Validates that a search-params.ts file's default export is statically
- * analyzable — a createSearchParams() call or a chain of .extend()/.pick()
- * calls on a SearchParamsDefinition.
- *
- * Non-analyzable files produce a hard build error with a diagnostic.
- *
- * Design doc: design/09-typescript.md §"Static Analyzability"
- */
-/** Result of analyzing a search-params.ts file. */
-export interface AnalyzeResult {
-    /** Whether the file is statically analyzable. */
-    valid: boolean;
-    /** Error details when valid is false. */
-    error?: AnalyzeError;
-}
-/** Diagnostic error for non-analyzable search-params.ts. */
-export interface AnalyzeError {
-    /** Absolute file path. */
-    filePath: string;
-    /** Description of the non-analyzable expression. */
-    expression: string;
-    /** Suggested fix. */
-    suggestion: string;
-}
-/**
- * Patterns that indicate a valid default export:
- *
- * 1. `export default createSearchParams(...)`
- * 2. `export default someVar.extend(...)`
- * 3. `export default someVar.pick(...)`
- * 4. `export default someVar.extend(...).extend(...)`  (chained)
- * 5. `export default someVar.extend(...).pick(...)`    (chained)
- * 6. `export default createSearchParams(...).extend(...)`
- *
- * Invalid patterns:
- * - `export default someFunction(...)` (arbitrary factory)
- * - `export default condition ? a : b` (runtime conditional)
- * - `export default variable` (opaque reference without call)
- */
-/**
- * Analyze a search-params.ts file source for static analyzability.
- *
- * @param source - The file content as a string
- * @param filePath - Absolute path to the file (for diagnostics)
- */
-export declare function analyzeSearchParams(source: string, filePath: string): AnalyzeResult;
-/**
- * Format an AnalyzeError into a human-readable build error message.
- */
-export declare function formatAnalyzeError(error: AnalyzeError): string;
-//# sourceMappingURL=analyze.d.ts.map

package/dist/search-params/analyze.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/search-params/analyze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,mDAAmD;AACnD,MAAM,WAAW,aAAa;IAC5B,iDAAiD;IACjD,KAAK,EAAE,OAAO,CAAC;IACf,yCAAyC;IACzC,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,4DAA4D;AAC5D,MAAM,WAAW,YAAY;IAC3B,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAYD;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAmCnF;AA0ED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAa9D"}

package/dist/search-params/builtin-codecs.d.ts

@@ -1,105 +0,0 @@
-/**
- * Built-in search param codecs for common types.
- *
- * These provide zero-dependency alternatives to nuqs parsers for the most
- * common cases: strings, integers, floats, booleans, and string enums.
- *
- * All codecs implement SearchParamCodec<T | null> — returning null when the
- * param is absent or unparseable. Use withDefault() to replace null with a
- * concrete fallback value.
- *
- * Design doc: design/23-search-params.md §"Identified Gaps" #1
- * Task: TIM-362
- */
-import type { SearchParamCodec } from './create.js';
-/**
- * String codec. Returns the raw string value, or null if absent.
- *
- * ```ts
- * import { parseAsString } from '@timber-js/app/search-params'
- *
- * const def = createSearchParams({ q: parseAsString })
- * // ?q=shoes → { q: 'shoes' }
- * // (absent) → { q: null }
- * ```
- */
-export declare const parseAsString: SearchParamCodec<string | null>;
-/**
- * Integer codec. Parses a base-10 integer, or returns null if absent or
- * not a valid integer. Rejects floats, NaN, Infinity, and non-numeric strings.
- *
- * ```ts
- * import { parseAsInteger, withDefault } from '@timber-js/app/search-params'
- *
- * const def = createSearchParams({ page: withDefault(parseAsInteger, 1) })
- * // ?page=2 → { page: 2 }
- * // ?page=abc → { page: 1 }
- * // (absent) → { page: 1 }
- * ```
- */
-export declare const parseAsInteger: SearchParamCodec<number | null>;
-/**
- * Float codec. Parses a finite number, or returns null if absent or invalid.
- * Rejects NaN and Infinity.
- *
- * ```ts
- * import { parseAsFloat, withDefault } from '@timber-js/app/search-params'
- *
- * const def = createSearchParams({ price: withDefault(parseAsFloat, 0) })
- * ```
- */
-export declare const parseAsFloat: SearchParamCodec<number | null>;
-/**
- * Boolean codec. Accepts "true"/"1" as true, "false"/"0" as false.
- * Returns null for absent or unrecognized values.
- *
- * ```ts
- * import { parseAsBoolean, withDefault } from '@timber-js/app/search-params'
- *
- * const def = createSearchParams({ debug: withDefault(parseAsBoolean, false) })
- * // ?debug=true → { debug: true }
- * // ?debug=0 → { debug: false }
- * ```
- */
-export declare const parseAsBoolean: SearchParamCodec<boolean | null>;
-/**
- * String enum codec. Accepts only values in the provided list.
- * Returns null for absent or invalid values.
- *
- * ```ts
- * import { parseAsStringEnum, withDefault } from '@timber-js/app/search-params'
- *
- * const sortCodec = withDefault(
- *   parseAsStringEnum(['price', 'name', 'date']),
- *   'date'
- * )
- * ```
- */
-export declare function parseAsStringEnum<T extends string>(values: readonly T[]): SearchParamCodec<T | null>;
-/**
- * String literal codec. Functionally identical to parseAsStringEnum but
- * accepts `as const` tuples for narrower type inference.
- *
- * ```ts
- * import { parseAsStringLiteral } from '@timber-js/app/search-params'
- *
- * const sizes = ['sm', 'md', 'lg', 'xl'] as const
- * const codec = parseAsStringLiteral(sizes)
- * // Type: SearchParamCodec<'sm' | 'md' | 'lg' | 'xl' | null>
- * ```
- */
-export declare function parseAsStringLiteral<const T extends readonly string[]>(values: T): SearchParamCodec<T[number] | null>;
-/**
- * Wrap a nullable codec with a default value. When the inner codec returns
- * null, the default is used instead. The output type becomes non-nullable.
- *
- * ```ts
- * import { parseAsInteger, withDefault } from '@timber-js/app/search-params'
- *
- * const page = withDefault(parseAsInteger, 1)
- * // page.parse(undefined) → 1 (not null)
- * // page.parse('5') → 5
- * ```
- */
-export declare function withDefault<T>(codec: SearchParamCodec<T | null>, defaultValue: T): SearchParamCodec<T>;
-//# sourceMappingURL=builtin-codecs.d.ts.map

package/dist/search-params/builtin-codecs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtin-codecs.d.ts","sourceRoot":"","sources":["../../src/search-params/builtin-codecs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAqBpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,EAAE,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAQzD,CAAC;AAMF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAW1D,CAAC;AAMF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAWxD,CAAC;AAMF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,CAAC,OAAO,GAAG,IAAI,CAW3D,CAAC;AAMF;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,MAAM,EAAE,SAAS,CAAC,EAAE,GACnB,gBAAgB,CAAC,CAAC,GAAG,IAAI,CAAC,CAY5B;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EACpE,MAAM,EAAE,CAAC,GACR,gBAAgB,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAGpC;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,gBAAgB,CAAC,CAAC,GAAG,IAAI,CAAC,EACjC,YAAY,EAAE,CAAC,GACd,gBAAgB,CAAC,CAAC,CAAC,CAUrB"}

package/dist/search-params/codecs.d.ts

@@ -1,53 +0,0 @@
-/**
- * Built-in codecs and the fromSchema bridge for Standard Schema-compatible
- * validation libraries (Zod, Valibot, ArkType).
- *
- * Design doc: design/09-typescript.md §"The SearchParamCodec Protocol"
- */
-import type { SearchParamCodec } from './create.js';
-interface StandardSchemaV1<Output = unknown> {
-    '~standard': {
-        validate(value: unknown): StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
-    };
-}
-type StandardSchemaResult<Output> = {
-    value: Output;
-    issues?: undefined;
-} | {
-    value?: undefined;
-    issues: ReadonlyArray<{
-        message: string;
-    }>;
-};
-/**
- * Bridge a Standard Schema-compatible schema (Zod, Valibot, ArkType) to a
- * SearchParamCodec.
- *
- * Parse: coerces the raw URL string through the schema. On validation failure,
- * parses `undefined` to get the schema's default value (the schema should have
- * a `.default()` call). If that also fails, returns `undefined`.
- *
- * Serialize: uses `String()` for primitives, `null` for null/undefined.
- *
- * ```ts
- * import { fromSchema } from '@timber-js/app/search-params'
- * import { z } from 'zod/v4'
- *
- * const pageCodec = fromSchema(z.coerce.number().int().min(1).default(1))
- * ```
- */
-export declare function fromSchema<T>(schema: StandardSchemaV1<T>): SearchParamCodec<T>;
-/**
- * Bridge a Standard Schema for array values. Handles both single strings
- * and repeated query keys (`?tag=a&tag=b`).
- *
- * ```ts
- * import { fromArraySchema } from '@timber-js/app/search-params'
- * import { z } from 'zod/v4'
- *
- * const tagsCodec = fromArraySchema(z.array(z.string()).default([]))
- * ```
- */
-export declare function fromArraySchema<T>(schema: StandardSchemaV1<T>): SearchParamCodec<T>;
-export {};
-//# sourceMappingURL=codecs.d.ts.map

package/dist/search-params/codecs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../src/search-params/codecs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAUpD,UAAU,gBAAgB,CAAC,MAAM,GAAG,OAAO;IACzC,WAAW,EAAE;QACX,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC;KAChG,CAAC;CACH;AAED,KAAK,oBAAoB,CAAC,MAAM,IAC5B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GACrC;IAAE,KAAK,CAAC,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC;AA6BtE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CA6B9E;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAmCnF"}