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

package/dist/server/flush.d.ts

@@ -1,74 +0,0 @@
-/**
- * Flush controller for timber.js rendering.
- *
- * Holds the response until `onShellReady` fires, then commits the HTTP status
- * code and flushes the shell. Render-phase signals (deny, redirect, unhandled
- * throws) caught before flush produce correct HTTP status codes.
- *
- * See design/02-rendering-pipeline.md §"The Flush Point" and §"The Hold Window"
- */
-/** The readable stream from React's renderToReadableStream. */
-export interface ReactRenderStream {
-    /** The underlying ReadableStream of HTML bytes. */
-    readable: ReadableStream<Uint8Array>;
-    /** Resolves when the shell has finished rendering (all non-Suspense content). */
-    allReady?: Promise<void>;
-}
-/** Options for the flush controller. */
-export interface FlushOptions {
-    /** Response headers to include (from middleware.ts, proxy.ts, etc.). */
-    responseHeaders?: Headers;
-    /** Default status code when rendering succeeds. Default: 200. */
-    defaultStatus?: number;
-}
-/** Result of the flush process. */
-export interface FlushResult {
-    /** The final HTTP Response. */
-    response: Response;
-    /** The status code committed. */
-    status: number;
-    /** Whether the response was a redirect. */
-    isRedirect: boolean;
-    /** Whether the response was a denial. */
-    isDenial: boolean;
-}
-/**
- * A function that performs the React render.
- *
- * The flush controller calls this, catches any signals thrown during the
- * synchronous shell render (before onShellReady), and produces the
- * correct HTTP response.
- *
- * Must return an object with:
- * - `stream`: The ReadableStream from renderToReadableStream
- * - `shellReady`: A Promise that resolves when onShellReady fires
- */
-export interface RenderResult {
-    /** The HTML byte stream. */
-    stream: ReadableStream<Uint8Array>;
-    /** Resolves when the shell is ready (all non-Suspense content rendered). */
-    shellReady: Promise<void>;
-}
-export type RenderFn = () => RenderResult | Promise<RenderResult>;
-/**
- * Execute a render and hold the response until the shell is ready.
- *
- * The flush controller:
- * 1. Calls the render function to start renderToReadableStream
- * 2. Waits for shellReady (onShellReady)
- * 3. If a render-phase signal was thrown (deny, redirect, error), produces
- *    the correct HTTP status code
- * 4. If the shell rendered successfully, commits the status and streams
- *
- * Render-phase signals caught before flush:
- * - `DenySignal` → HTTP 4xx with appropriate status code
- * - `RedirectSignal` → HTTP 3xx with Location header
- * - `RenderError` → HTTP status from error (default 500)
- * - Unhandled error → HTTP 500
- *
- * @param renderFn - Function that starts the React render.
- * @param options - Flush configuration.
- * @returns The committed HTTP Response.
- */
-export declare function flushResponse(renderFn: RenderFn, options?: FlushOptions): Promise<FlushResult>;
-//# sourceMappingURL=flush.d.ts.map

package/dist/server/flush.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flush.d.ts","sourceRoot":"","sources":["../../src/server/flush.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACrC,iFAAiF;IACjF,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,wCAAwC;AACxC,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,mCAAmC;AACnC,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,QAAQ,EAAE,QAAQ,CAAC;IACnB,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;IACpB,yCAAyC;IACzC,QAAQ,EAAE,OAAO,CAAC;CACnB;AAID;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,4BAA4B;IAC5B,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACnC,4EAA4E;IAC5E,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAIlE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,WAAW,CAAC,CAiCtB"}

package/dist/server/manifest-status-resolver.d.ts

@@ -1,58 +0,0 @@
-/**
- * Manifest-compatible status-code file resolver.
- *
- * The existing status-code-resolver.ts works with SegmentNode (Map-based).
- * This module works with ManifestSegmentNode (object-based) for use at
- * runtime in the RSC/SSR entries, where the route manifest provides
- * plain objects instead of Maps.
- *
- * Supports two format families:
- * - 'component' (default): .tsx/.jsx/.mdx status files → React rendering pipeline
- * - 'json': .json status files → raw JSON response, no React
- *
- * Follows the same fallback chains as status-code-resolver.ts:
- *
- * **Component chain (4xx):**
- *   Pass 1 — status files (leaf → root): {status}.tsx → 4xx.tsx
- *   Pass 2 — legacy compat (leaf → root): not-found.tsx / forbidden.tsx / unauthorized.tsx
- *   Pass 3 — error.tsx (leaf → root)
- *   Pass 4 — framework default (returns null)
- *
- * **JSON chain (4xx):**
- *   Pass 1 — json status files (leaf → root): {status}.json → 4xx.json
- *   Pass 2 — framework default JSON (returns null, caller provides bare JSON)
- *
- * See design/10-error-handling.md §"Status-Code Files"
- */
-import type { ManifestSegmentNode } from './route-matcher.js';
-/** A file reference in the manifest (lazy import + path). */
-interface ManifestFile {
-    load: () => Promise<unknown>;
-    filePath: string;
-}
-/** How the status-code file was matched. */
-export type ManifestStatusFileKind = 'exact' | 'category' | 'legacy' | 'error';
-/** Response format family for status-code resolution. */
-export type ManifestStatusFileFormat = 'component' | 'json';
-/** Result of resolving a status-code file from manifest segments. */
-export interface ManifestStatusFileResolution {
-    /** The matched manifest file (has load() and filePath). */
-    file: ManifestFile;
-    /** The HTTP status code (always the original status, not the file's code). */
-    status: number;
-    /** How the file was matched. */
-    kind: ManifestStatusFileKind;
-    /** Index into the segments array where the file was found. */
-    segmentIndex: number;
-}
-/**
- * Resolve the status-code file to render for a given HTTP status code,
- * using manifest segment nodes (plain objects, not Maps).
- *
- * @param status - The HTTP status code (4xx or 5xx).
- * @param segments - The matched segment chain from root (index 0) to leaf (last).
- * @param format - The response format family ('component' or 'json'). Defaults to 'component'.
- */
-export declare function resolveManifestStatusFile(status: number, segments: ReadonlyArray<ManifestSegmentNode>, format?: ManifestStatusFileFormat): ManifestStatusFileResolution | null;
-export {};
-//# sourceMappingURL=manifest-status-resolver.d.ts.map

package/dist/server/manifest-status-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest-status-resolver.d.ts","sourceRoot":"","sources":["../../src/server/manifest-status-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAI9D,6DAA6D;AAC7D,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,4CAA4C;AAC5C,MAAM,MAAM,sBAAsB,GAC9B,OAAO,GACP,UAAU,GACV,QAAQ,GACR,OAAO,CAAC;AAEZ,yDAAyD;AACzD,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,MAAM,CAAC;AAE5D,qEAAqE;AACrE,MAAM,WAAW,4BAA4B;IAC3C,2DAA2D;IAC3D,IAAI,EAAE,YAAY,CAAC;IACnB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAC;CACtB;AAYD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAC5C,MAAM,GAAE,wBAAsC,GAC7C,4BAA4B,GAAG,IAAI,CAcrC"}

package/dist/server/prerender.d.ts

@@ -1,77 +0,0 @@
-/**
- * Pre-rendering types and utilities.
- *
- * A `prerender.ts` file in a route segment signals the framework to
- * pre-render the route's shell at build time. This module defines the
- * types that a user exports from `prerender.ts` and utilities for
- * loading and validating those exports.
- *
- * Design doc: design/15-future-prerendering.md
- */
-/**
- * The shape of a prerender.ts module's exports.
- *
- * ```ts
- * // app/docs/[slug]/prerender.ts
- * export async function generateParams() {
- *   return docs.map(d => ({ slug: d.slug }))
- * }
- * export const ttl = '1h'
- * export const tags = ['docs']
- * ```
- */
-export interface PrerenderConfig {
-    /**
-     * Generate the set of params to pre-render at build time.
-     * Required for dynamic segments (`[param]`).
-     * Optional for static segments (the single URL is pre-rendered automatically).
-     */
-    generateParams?: () => Promise<Record<string, string>[]> | Record<string, string>[];
-    /**
-     * How long the pre-rendered shell is considered fresh.
-     * Accepts duration strings ('30s', '5m', '1h', '2d', '1w') or seconds as a number.
-     * Default: Infinity (cache until explicit invalidation).
-     */
-    ttl?: string | number;
-    /**
-     * Invalidation tags. Calling `revalidateTag('docs')` purges all
-     * pre-rendered shells with that tag.
-     */
-    tags?: string[];
-    /**
-     * Fallback strategy for dynamic routes without `generateParams`.
-     * Only valid in `output: 'static'` mode.
-     * - `'shell'`: emit a single pre-rendered shell that serves as client-side fallback
-     */
-    fallback?: 'shell';
-}
-export interface ResolvedPrerenderConfig {
-    /** TTL in seconds. Infinity if not set. */
-    ttlSeconds: number;
-    /** Invalidation tags */
-    tags: string[];
-    /** The generateParams function, if provided */
-    generateParams?: () => Promise<Record<string, string>[]> | Record<string, string>[];
-    /** Fallback strategy */
-    fallback?: 'shell';
-}
-/**
- * Resolve raw prerender.ts exports into a normalized config.
- *
- * Validates:
- * - `ttl` is a valid duration string or number
- * - `tags` is an array of strings
- * - `fallback` is 'shell' or undefined
- */
-export declare function resolvePrerenderConfig(raw: PrerenderConfig): ResolvedPrerenderConfig;
-export interface PrerenderDiagnostic {
-    type: 'DYNAMIC_SEGMENT_NO_PARAMS';
-    segmentPath: string;
-    message: string;
-}
-/**
- * Check if a dynamic segment has `generateParams` when prerender.ts is present.
- * If not, emit a diagnostic — the route falls back to SSR.
- */
-export declare function checkDynamicSegmentParams(segmentPath: string, isDynamic: boolean, hasGenerateParams: boolean, fallback?: 'shell'): PrerenderDiagnostic | null;
-//# sourceMappingURL=prerender.d.ts.map

package/dist/server/prerender.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prerender.d.ts","sourceRoot":"","sources":["../../src/server/prerender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAEpF;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEtB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAMD,MAAM,WAAW,uBAAuB;IACtC,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,wBAAwB;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,+CAA+C;IAC/C,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACpF,wBAAwB;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,eAAe,GAAG,uBAAuB,CAsBpF;AAMD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,2BAA2B,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,OAAO,EAClB,iBAAiB,EAAE,OAAO,EAC1B,QAAQ,CAAC,EAAE,OAAO,GACjB,mBAAmB,GAAG,IAAI,CAc5B"}

package/dist/utils/directive-parser.d.ts

@@ -1,70 +0,0 @@
-/**
- * AST-based directive detection for 'use cache', 'use dynamic',
- * 'use client', and 'use server'.
- *
- * Uses acorn to parse source code and detect directives properly,
- * avoiding false positives from regex matching inside string literals,
- * comments, or template expressions.
- *
- * @module
- */
-export interface FileDirective {
-    /** The directive value, e.g. 'use client', 'use server' */
-    directive: string;
-    /** 1-based line number where the directive appears */
-    line: number;
-}
-export interface FunctionWithDirective {
-    /** Function name (or 'default' for anonymous default exports) */
-    name: string;
-    /** The directive found in the function body */
-    directive: string;
-    /** 1-based line number of the directive */
-    directiveLine: number;
-    /** Start offset of the function in the source */
-    start: number;
-    /** End offset of the function in the source */
-    end: number;
-    /** Start offset of the function body block (after the '{') */
-    bodyStart: number;
-    /** End offset of the function body block (the '}') */
-    bodyEnd: number;
-    /** Content between { and } of the function body */
-    bodyContent: string;
-    /** 'export ', 'export default ', or '' */
-    prefix: string;
-    /** Whether this is an arrow function */
-    isArrow: boolean;
-    /** The function signature (everything before the body '{') */
-    declaration: string;
-}
-/**
- * Detect a file-level directive ('use client', 'use server', etc.).
- *
- * Per the ECMAScript spec, directives are string literal expression
- * statements at the start of a program body (before any non-directive
- * statements). This function checks the AST `Program.body` for
- * `ExpressionStatement` nodes whose expression is a `Literal` string
- * matching a known directive.
- *
- * Returns the first matching directive, or null if none found.
- */
-export declare function detectFileDirective(code: string, directives?: string[]): FileDirective | null;
-/**
- * Find all functions in the source code that contain a directive
- * (e.g. 'use cache', 'use dynamic') as their first body statement.
- *
- * Parses the source with acorn and walks the AST looking for function
- * declarations and arrow function expressions whose body is a
- * BlockStatement with a directive prologue.
- *
- * Returns an array of function info objects, sorted by position
- * (descending) for safe end-to-start replacement.
- */
-export declare function findFunctionsWithDirective(code: string, directive: string): FunctionWithDirective[];
-/**
- * Quick regex check for whether code contains a directive string.
- * Use as a fast bail-out before calling the AST-based functions.
- */
-export declare function containsDirective(code: string, directive: string): boolean;
-//# sourceMappingURL=directive-parser.d.ts.map

package/dist/utils/directive-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"directive-parser.d.ts","sourceRoot":"","sources":["../../src/utils/directive-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAYH,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,aAAa,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;CACrB;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAAM,EAAiC,GAClD,aAAa,GAAG,IAAI,CAmCtB;AAiED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,qBAAqB,EAAE,CAqBzB;AA4TD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAE1E"}

package/src/cache/register-cached-function.ts

@@ -1,103 +0,0 @@
-import type { CacheHandler } from './index';
-import { stableStringify } from './stable-stringify';
-import { createSingleflight } from './singleflight';
-import { fnv1aHash } from './fast-hash.js';
-
-const singleflight = createSingleflight();
-
-// Prop names that suggest request-specific data — triggers dev warning for "use cache" components.
-const REQUEST_SPECIFIC_PROPS = new Set([
-  'cookies',
-  'cookie',
-  'session',
-  'sessionId',
-  'token',
-  'authorization',
-  'auth',
-  'headers',
-]);
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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;
-}
-
-/**
- * Generate a cache key from a stable function ID and serialized args.
- *
- * Uses FNV-1a (fast non-crypto hash) instead of SHA-256. The id prefix
- * provides namespace isolation; the hash covers the args.
- * See TIM-370.
- */
-function generateKey(id: string, args: unknown[]): string {
-  const raw = id + ':' + stableStringify(args);
-  return id + ':' + fnv1aHash(raw);
-}
-
-/**
- * Resolve tags from options — supports static array or function form.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function resolveTags<Fn extends (...args: any[]) => any>(
-  opts: RegisterCachedFunctionOptions<Fn>,
-  args: Parameters<Fn>
-): string[] {
-  if (!opts.tags) return [];
-  if (Array.isArray(opts.tags)) return opts.tags;
-  return opts.tags(...args);
-}
-
-/**
- * Checks if component props contain request-specific keys and emits a dev warning.
- * Only runs when process.env.NODE_ENV !== 'production'.
- */
-function warnRequestSpecificProps(id: string, props: unknown): void {
-  if (typeof props !== 'object' || props === null) return;
-  const keys = Object.keys(props);
-  const suspicious = keys.filter((k) => REQUEST_SPECIFIC_PROPS.has(k.toLowerCase()));
-  if (suspicious.length > 0) {
-    console.warn(
-      `[timber] "use cache" component ${id} received request-specific props: ${suspicious.join(', ')}. ` +
-        `This may serve one user's cached render to another user. ` +
-        `Remove request-specific data from props or remove "use cache".`
-    );
-  }
-}
-
-/**
- * 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.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function registerCachedFunction<Fn extends (...args: any[]) => Promise<any>>(
-  fn: Fn,
-  opts: RegisterCachedFunctionOptions<Fn>,
-  handler: CacheHandler
-): (...args: Parameters<Fn>) => Promise<Awaited<ReturnType<Fn>>> {
-  return async (...args: Parameters<Fn>): Promise<Awaited<ReturnType<Fn>>> => {
-    // Dev-mode warning for components with request-specific props
-    if (opts.isComponent && process.env.NODE_ENV !== 'production' && args.length > 0) {
-      warnRequestSpecificProps(opts.id, args[0]);
-    }
-
-    const key = generateKey(opts.id, args);
-    const cached = await handler.get(key);
-
-    if (cached && !cached.stale) {
-      return cached.value as Awaited<ReturnType<Fn>>;
-    }
-
-    // Cache miss or stale — execute with singleflight
-    const result = await singleflight.do(key, () => fn(...args));
-    const tags = resolveTags(opts, args);
-    await handler.set(key, result, { ttl: opts.ttl, tags });
-    return result as Awaited<ReturnType<Fn>>;
-  };
-}