@timber-js/app 0.2.0-alpha.19 → 0.2.0-alpha.190

package/dist/cache/register-cached-function.d.ts

@@ -1,17 +0,0 @@
-import type { CacheHandler } from './index';
-export interface RegisterCachedFunctionOptions<Fn extends (...args: any[]) => any> {
-    ttl: number;
-    id: string;
-    tags?: string[] | ((...args: Parameters<Fn>) => string[]);
-    /** True when the cached function is a React component (PascalCase name). */
-    isComponent?: boolean;
-}
-/**
- * Runtime for the "use cache" directive transform. Wraps an async function
- * with caching using the same cache handler as timber.cache.
- *
- * The stable `id` (file path + function name) ensures cache keys are consistent
- * across builds. Args/props are hashed with SHA-256 for the per-call key.
- */
-export declare function registerCachedFunction<Fn extends (...args: any[]) => Promise<any>>(fn: Fn, opts: RegisterCachedFunctionOptions<Fn>, handler: CacheHandler): (...args: Parameters<Fn>) => Promise<Awaited<ReturnType<Fn>>>;
-//# sourceMappingURL=register-cached-function.d.ts.map

package/dist/cache/register-cached-function.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"register-cached-function.d.ts","sourceRoot":"","sources":["../../src/cache/register-cached-function.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAoB5C,MAAM,WAAW,6BAA6B,CAAC,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;IAC/E,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC;IAC1D,4EAA4E;IAC5E,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AA4CD;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAChF,EAAE,EAAE,EAAE,EACN,IAAI,EAAE,6BAA6B,CAAC,EAAE,CAAC,EACvC,OAAO,EAAE,YAAY,GACpB,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAoB/D"}

package/dist/client/browser-entry.d.ts

@@ -1,21 +0,0 @@
-/**
- * Browser Entry — Client-side hydration and navigation bootstrap.
- *
- * This is a real TypeScript file, not codegen. It initializes the
- * client navigation runtime: segment router, prefetch cache, and
- * history stack.
- *
- * Hydration works by:
- * 1. Decoding the RSC payload embedded in the initial HTML response
- *    via createFromReadableStream from @vitejs/plugin-rsc/browser
- * 2. Hydrating the decoded React tree via hydrateRoot
- * 3. Setting up client-side navigation for subsequent page transitions
- *
- * After hydration, the browser entry:
- * - Link click handling is per-component (Link's onClick), not global delegation
- * - Listens for popstate events for back/forward navigation
- *
- * Design docs: 18-build-system.md §"Entry Files", 19-client-navigation.md
- */
-export {};
-//# sourceMappingURL=browser-entry.d.ts.map

package/dist/client/browser-entry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser-entry.d.ts","sourceRoot":"","sources":["../../src/client/browser-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/client/error-boundary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-boundary.js","names":[],"sources":["../../src/client/error-boundary.tsx"],"sourcesContent":["'use client';\n\n/**\n * Framework-injected React error boundary.\n *\n * Catches errors thrown by children and renders a fallback component\n * with the appropriate props based on error type:\n *   - DenySignal (4xx) → { status, dangerouslyPassData }\n *   - RenderError (5xx) → { error, digest, reset }\n *   - Unhandled error → { error, digest: null, reset }\n *\n * The `status` prop controls which errors this boundary catches:\n *   - Specific code (e.g. 403) → only that status\n *   - Category (400) → any 4xx\n *   - Category (500) → any 5xx\n *   - Omitted → catches everything (error.tsx behavior)\n *\n * See design/10-error-handling.md §\"Status-Code Files\"\n */\n\nimport { Component, createElement, type ReactNode } from 'react';\nimport { getSsrData } from './ssr-data.js';\n\n// ─── Page Unload Detection ───────────────────────────────────────────────────\n// Track whether the page is being unloaded (user refreshed or navigated away).\n// When this is true, error boundaries suppress activation — the error is from\n// the aborted connection, not an application error.\nlet _isUnloading = false;\nif (typeof window !== 'undefined') {\n  window.addEventListener('beforeunload', () => {\n    _isUnloading = true;\n  });\n  window.addEventListener('pagehide', () => {\n    _isUnloading = true;\n  });\n}\n\n// ─── Digest Types ────────────────────────────────────────────────────────────\n\n/** Structured digest returned by RSC onError for DenySignal. */\ninterface DenyDigest {\n  type: 'deny';\n  status: number;\n  data: unknown;\n}\n\n/** Structured digest returned by RSC onError for RenderError. */\ninterface RenderErrorDigest {\n  type: 'render-error';\n  code: string;\n  data: unknown;\n  status: number;\n}\n\n/** Structured digest returned by RSC onError for RedirectSignal. */\ninterface RedirectDigest {\n  type: 'redirect';\n  location: string;\n  status: number;\n}\n\ntype ParsedDigest = DenyDigest | RenderErrorDigest | RedirectDigest;\n\n// ─── Props & State ───────────────────────────────────────────────────────────\n\nexport interface TimberErrorBoundaryProps {\n  /** The component to render when an error is caught. */\n  fallbackComponent: (...args: unknown[]) => ReactNode;\n  /**\n   * Status code filter. If set, only catches errors matching this status.\n   * 400 = any 4xx, 500 = any 5xx, specific number = exact match.\n   */\n  status?: number;\n  /**\n   * When true, catching a DenySignal sets _denyHandledByBoundary on the\n   * nav context to prevent page-level deny promotion. Only slot catch-all\n   * boundaries should set this — segment boundaries (403.tsx, 4xx.tsx,\n   * error.tsx) must NOT, otherwise normal page denies get swallowed.\n   */\n  isSlotBoundary?: boolean;\n  children: ReactNode;\n}\n\ninterface TimberErrorBoundaryState {\n  hasError: boolean;\n  error: Error | null;\n}\n\n// ─── Component ───────────────────────────────────────────────────────────────\n\nexport class TimberErrorBoundary extends Component<\n  TimberErrorBoundaryProps,\n  TimberErrorBoundaryState\n> {\n  constructor(props: TimberErrorBoundaryProps) {\n    super(props);\n    this.state = { hasError: false, error: null };\n  }\n\n  static getDerivedStateFromError(error: Error): TimberErrorBoundaryState {\n    // Suppress error boundaries during page unload (refresh/navigate away).\n    // The aborted connection causes React's streaming hydration to error,\n    // but the page is about to be replaced — showing an error boundary\n    // would be a jarring flash for the user.\n    if (_isUnloading) {\n      return { hasError: false, error: null };\n    }\n\n    return { hasError: true, error };\n  }\n\n  componentDidUpdate(prevProps: TimberErrorBoundaryProps): void {\n    // Reset error state when children change (e.g. client-side navigation).\n    // Without this, navigating from one error page to another keeps the\n    // stale error — getDerivedStateFromError doesn't re-fire for new children.\n    if (this.state.hasError && prevProps.children !== this.props.children) {\n      this.setState({ hasError: false, error: null });\n    }\n  }\n\n  /** Reset the error state so children re-render. */\n  private reset = () => {\n    this.setState({ hasError: false, error: null });\n  };\n\n  render(): ReactNode {\n    if (!this.state.hasError || !this.state.error) {\n      return this.props.children;\n    }\n\n    const error = this.state.error;\n    const parsed = parseDigest(error);\n\n    // RedirectSignal errors must propagate through all error boundaries\n    // so the SSR shell fails and the pipeline catch block can produce a\n    // proper HTTP redirect response. See design/04-authorization.md.\n    if (parsed?.type === 'redirect') {\n      throw error;\n    }\n\n    // If this boundary has a status filter, check whether the error matches.\n    // Non-matching errors re-throw so an outer boundary can catch them.\n    if (this.props.status != null) {\n      const errorStatus = getErrorStatus(parsed, error);\n      if (errorStatus == null || !statusMatches(this.props.status, errorStatus)) {\n        // Re-throw: this boundary doesn't handle this error.\n        throw error;\n      }\n    }\n\n    // Report DenySignal handling to prevent page-level promotion — but only\n    // for slot boundaries. Segment boundaries (403.tsx, 4xx.tsx, error.tsx)\n    // must NOT set this flag, otherwise normal page/hold-window denies get\n    // swallowed as 200 with boundary HTML instead of the intended 4xx.\n    // Runs here in render() (not getDerivedStateFromError) so the status\n    // filter has already been applied — non-matching boundaries re-threw above.\n    // See LOCAL-298.\n    if (parsed?.type === 'deny' && this.props.isSlotBoundary) {\n      const ssrData = getSsrData();\n      if (ssrData?._navContext) {\n        ssrData._navContext._denyHandledByBoundary = true;\n      }\n    }\n\n    // Render the fallback component with the right props shape.\n    if (parsed?.type === 'deny') {\n      return createElement(this.props.fallbackComponent as never, {\n        status: parsed.status,\n        dangerouslyPassData: parsed.data,\n      });\n    }\n\n    // 5xx / RenderError / unhandled error\n    const digest =\n      parsed?.type === 'render-error' ? { code: parsed.code, data: parsed.data } : null;\n\n    return createElement(this.props.fallbackComponent as never, {\n      error,\n      digest,\n      reset: this.reset,\n    });\n  }\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\n/**\n * Parse the structured digest from the error.\n * React sets `error.digest` from the string returned by RSC's onError.\n */\nfunction parseDigest(error: Error): ParsedDigest | null {\n  const raw = (error as { digest?: string }).digest;\n  if (typeof raw !== 'string') return null;\n  try {\n    const parsed = JSON.parse(raw);\n    if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {\n      return parsed as ParsedDigest;\n    }\n  } catch {\n    // Not JSON — legacy or unknown digest format\n  }\n  return null;\n}\n\n/**\n * Extract the HTTP status code from a parsed digest or error message.\n * Falls back to message pattern matching for errors without a digest.\n */\nfunction getErrorStatus(parsed: ParsedDigest | null, error: Error): number | null {\n  if (parsed?.type === 'deny') return parsed.status;\n  if (parsed?.type === 'render-error') return parsed.status;\n  if (parsed?.type === 'redirect') return parsed.status;\n\n  // Fallback: parse DenySignal message pattern for errors that lost their digest\n  const match = error.message.match(/^Access denied with status (\\d+)$/);\n  if (match) return parseInt(match[1], 10);\n\n  // Unhandled errors are implicitly 500\n  return 500;\n}\n\n/**\n * Check whether an error's status matches the boundary's status filter.\n * Category markers (400, 500) match any status in that range.\n */\nfunction statusMatches(boundaryStatus: number, errorStatus: number): boolean {\n  // Category catch-all: 400 matches any 4xx, 500 matches any 5xx\n  if (boundaryStatus === 400) return errorStatus >= 400 && errorStatus <= 499;\n  if (boundaryStatus === 500) return errorStatus >= 500 && errorStatus <= 599;\n  // Exact match\n  return boundaryStatus === errorStatus;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAI,eAAe;AACnB,IAAI,OAAO,WAAW,aAAa;AACjC,QAAO,iBAAiB,sBAAsB;AAC5C,iBAAe;GACf;AACF,QAAO,iBAAiB,kBAAkB;AACxC,iBAAe;GACf;;AAwDJ,IAAa,sBAAb,cAAyC,UAGvC;CACA,YAAY,OAAiC;AAC3C,QAAM,MAAM;AACZ,OAAK,QAAQ;GAAE,UAAU;GAAO,OAAO;GAAM;;CAG/C,OAAO,yBAAyB,OAAwC;AAKtE,MAAI,aACF,QAAO;GAAE,UAAU;GAAO,OAAO;GAAM;AAGzC,SAAO;GAAE,UAAU;GAAM;GAAO;;CAGlC,mBAAmB,WAA2C;AAI5D,MAAI,KAAK,MAAM,YAAY,UAAU,aAAa,KAAK,MAAM,SAC3D,MAAK,SAAS;GAAE,UAAU;GAAO,OAAO;GAAM,CAAC;;;CAKnD,cAAsB;AACpB,OAAK,SAAS;GAAE,UAAU;GAAO,OAAO;GAAM,CAAC;;CAGjD,SAAoB;AAClB,MAAI,CAAC,KAAK,MAAM,YAAY,CAAC,KAAK,MAAM,MACtC,QAAO,KAAK,MAAM;EAGpB,MAAM,QAAQ,KAAK,MAAM;EACzB,MAAM,SAAS,YAAY,MAAM;AAKjC,MAAI,QAAQ,SAAS,WACnB,OAAM;AAKR,MAAI,KAAK,MAAM,UAAU,MAAM;GAC7B,MAAM,cAAc,eAAe,QAAQ,MAAM;AACjD,OAAI,eAAe,QAAQ,CAAC,cAAc,KAAK,MAAM,QAAQ,YAAY,CAEvE,OAAM;;AAWV,MAAI,QAAQ,SAAS,UAAU,KAAK,MAAM,gBAAgB;GACxD,MAAM,UAAU,YAAY;AAC5B,OAAI,SAAS,YACX,SAAQ,YAAY,yBAAyB;;AAKjD,MAAI,QAAQ,SAAS,OACnB,QAAO,cAAc,KAAK,MAAM,mBAA4B;GAC1D,QAAQ,OAAO;GACf,qBAAqB,OAAO;GAC7B,CAAC;EAIJ,MAAM,SACJ,QAAQ,SAAS,iBAAiB;GAAE,MAAM,OAAO;GAAM,MAAM,OAAO;GAAM,GAAG;AAE/E,SAAO,cAAc,KAAK,MAAM,mBAA4B;GAC1D;GACA;GACA,OAAO,KAAK;GACb,CAAC;;;;;;;AAUN,SAAS,YAAY,OAAmC;CACtD,MAAM,MAAO,MAA8B;AAC3C,KAAI,OAAO,QAAQ,SAAU,QAAO;AACpC,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,IAAI;AAC9B,MAAI,UAAU,OAAO,WAAW,YAAY,OAAO,OAAO,SAAS,SACjE,QAAO;SAEH;AAGR,QAAO;;;;;;AAOT,SAAS,eAAe,QAA6B,OAA6B;AAChF,KAAI,QAAQ,SAAS,OAAQ,QAAO,OAAO;AAC3C,KAAI,QAAQ,SAAS,eAAgB,QAAO,OAAO;AACnD,KAAI,QAAQ,SAAS,WAAY,QAAO,OAAO;CAG/C,MAAM,QAAQ,MAAM,QAAQ,MAAM,oCAAoC;AACtE,KAAI,MAAO,QAAO,SAAS,MAAM,IAAI,GAAG;AAGxC,QAAO;;;;;;AAOT,SAAS,cAAc,gBAAwB,aAA8B;AAE3E,KAAI,mBAAmB,IAAK,QAAO,eAAe,OAAO,eAAe;AACxE,KAAI,mBAAmB,IAAK,QAAO,eAAe,OAAO,eAAe;AAExE,QAAO,mBAAmB"}

package/dist/client/head.d.ts

@@ -1,16 +0,0 @@
-/** A rendered head element descriptor (matches server-side HeadElement from metadata.ts). */
-export interface HeadElement {
-    tag: 'title' | 'meta' | 'link';
-    content?: string;
-    attrs?: Record<string, string>;
-}
-/**
- * Apply resolved head elements to the DOM.
- *
- * - Sets document.title for <title> elements
- * - Creates <meta> and <link> tags with a data-timber-head marker
- * - Removes previous timber-managed tags to prevent accumulation
- * - Replaces existing SSR-rendered tags with the same name/property
- */
-export declare function applyHeadElements(elements: HeadElement[]): void;
-//# sourceMappingURL=head.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../../src/client/head.ts"],"names":[],"mappings":"AAaA,6FAA6F;AAC7F,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAID;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CA8B/D"}

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

@@ -1,11 +0,0 @@
-import type { ReactNode } from 'react';
-/**
- * Client component that reads the pending URL from PendingNavigationContext
- * and provides a scoped LinkStatusContext to children. Renders no extra DOM —
- * just a context provider around children.
- */
-export declare function LinkStatusProvider({ href, children }: {
-    href: string;
-    children?: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=link-status-provider.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"link-status-provider.d.ts","sourceRoot":"","sources":["../../src/client/link-status-provider.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAOvC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,2CAK5F"}

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

@@ -1,119 +0,0 @@
-/**
- * Segment Merger — client-side tree merging for partial RSC payloads.
- *
- * When the server skips rendering sync layouts (because the client already
- * has them cached), the RSC payload is missing outer segment wrappers.
- * This module reconstructs the full element tree by splicing the partial
- * payload into cached segment subtrees.
- *
- * The approach:
- * 1. After each full RSC payload render, walk the decoded element tree
- *    and cache each segment's subtree (identified by SegmentProvider boundaries)
- * 2. When a partial payload arrives, wrap it with cached segment elements
- *    using React.cloneElement to preserve component identity
- *
- * React.cloneElement preserves the element's `type` — React sees the same
- * component at the same tree position and reconciles (preserving state)
- * rather than remounting. This is how layout state survives navigations.
- *
- * Design docs: 19-client-navigation.md §"Navigation Reconciliation"
- * Security: access.ts runs on the server regardless of skipping — this
- *           is a performance optimization only. See 13-security.md.
- */
-import { type ReactElement, type ReactNode } from 'react';
-/**
- * A cached segment entry. Stores the full subtree rooted at a SegmentProvider
- * and the path through the tree to the next SegmentProvider (or leaf).
- */
-export interface CachedSegmentEntry {
-    /** The segment's URL path (e.g., "/", "/dashboard") */
-    segmentPath: string;
-    /** The SegmentProvider element for this segment */
-    element: ReactElement;
-    /**
-     * Whether this segment's cached element contains a nested SegmentProvider.
-     * Only segments with inner SegmentProviders are safe to skip — the merger
-     * can only replace inner SegmentProviders, not pages embedded in layout output.
-     * Used by the state tree serialization to exclude non-mergeable segments.
-     */
-    hasMergeableChild: boolean;
-}
-/**
- * Cache of React element subtrees per segment path.
- * Updated after each navigation with the full decoded RSC element tree.
- */
-export declare class SegmentElementCache {
-    private entries;
-    get(segmentPath: string): CachedSegmentEntry | undefined;
-    set(segmentPath: string, entry: CachedSegmentEntry): void;
-    has(segmentPath: string): boolean;
-    clear(): void;
-    get size(): number;
-    /**
-     * Get the set of segment paths that are safe for the server to skip.
-     * Only segments with an inner SegmentProvider (hasMergeableChild) are
-     * included — the merger can only replace inner SegmentProviders, not
-     * pages embedded in layout output. Used to filter the state tree.
-     *
-     * Returns an empty set if the element cache is empty (no elements
-     * cached yet). This is the safe default — an empty set means no
-     * segments pass the filter, so the state tree is empty and the server
-     * does a full render. The element cache is populated lazily after the
-     * first SPA navigation (RSC-decoded elements from hydration are
-     * thenables that can't be walked until React resolves them).
-     */
-    getMergeablePaths(): Set<string>;
-}
-/**
- * Check if a React element is a SegmentProvider by looking for the
- * `segments` prop (an array of path segments). This is the only
- * component that receives this prop shape.
- */
-export declare function isSegmentProvider(element: unknown): element is ReactElement;
-/**
- * Extract the segment path from a SegmentProvider element.
- *
- * Uses the `segmentId` prop if available (set by the server for route groups
- * to distinguish siblings that share the same urlPath). Falls back to
- * reconstructing from the `segments` array prop.
- */
-export declare function getSegmentPath(element: ReactElement): string;
-/**
- * Walk a React element tree and extract all SegmentProvider boundaries.
- * Returns an ordered list of segment entries from outermost to innermost.
- *
- * This only finds SegmentProviders along the main children path — it does
- * not descend into parallel routes/slots (those are separate subtrees).
- */
-export declare function extractSegments(element: unknown): CachedSegmentEntry[];
-/**
- * Cache all segment subtrees from a fully-rendered RSC element tree.
- * Call this after every full RSC payload render (navigate, refresh, hydration).
- */
-export declare function cacheSegmentElements(element: unknown, cache: SegmentElementCache): void;
-/**
- * Replace a nested SegmentProvider within a cached element tree with
- * new content. Uses cloneElement along the path to produce a new tree
- * with preserved component identity at every level except the replaced node.
- *
- * @param cachedElement The cached SegmentProvider element for this segment
- * @param newInnerContent The new React element to splice in at the inner segment position
- * @param innerSegmentPath The path of the inner segment to replace (optional — replaces first found)
- * @returns New element tree with the inner segment replaced
- */
-export declare function replaceInnerSegment(cachedElement: ReactElement, newInnerContent: ReactNode, innerSegmentPath?: string): ReactElement;
-/**
- * Merge a partial RSC payload with cached segment elements.
- *
- * When the server skips segments, the partial payload starts from the
- * first non-skipped segment. This function wraps it with cached elements
- * for the skipped segments, producing a full tree that React can
- * reconcile with the mounted tree (preserving layout state).
- *
- * @param partialPayload The RSC payload element (may be partial)
- * @param skippedSegments Ordered list of segment paths that were skipped (outermost first)
- * @param cache The segment element cache
- * @returns The merged full element tree, or the partial payload if merging isn't possible
- */
-export declare function mergeSegmentTree(partialPayload: unknown, skippedSegments: string[], cache: SegmentElementCache): unknown;
-//# sourceMappingURL=segment-merger.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"segment-merger.d.ts","sourceRoot":"","sources":["../../src/client/segment-merger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAgC,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIxF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,OAAO,EAAE,YAAY,CAAC;IACtB;;;;;OAKG;IACH,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAID;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAyC;IAExD,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIxD,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAIzD,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAIjC,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;OAYG;IACH,iBAAiB,IAAI,GAAG,CAAC,MAAM,CAAC;CASjC;AAID;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,YAAY,CAI3E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAM5D;AAID;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,kBAAkB,EAAE,CAUtE;AAuCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAKvF;AAkDD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,YAAY,EAC3B,eAAe,EAAE,SAAS,EAC1B,gBAAgB,CAAC,EAAE,MAAM,GACxB,YAAY,CAoCd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,OAAO,EACvB,eAAe,EAAE,MAAM,EAAE,EACzB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CA0BT"}

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"}