@timber-js/app 0.2.0-alpha.2 → 0.2.0-alpha.200

package/src/server/actions.ts

@@ -3,7 +3,7 @@
  *
  * - revalidatePath(path) re-renders the route at that path and returns the RSC
  *   flight payload for inline reconciliation.
- * - revalidateTag(tag) invalidates cached shells and 'use cache' entries by tag.
+ * - revalidateTag(tag) invalidates timber.cache entries by tag.
  *
  * Both are callable from anywhere on the server — actions, API routes, handlers.
  *
@@ -14,33 +14,41 @@
  * See design/08-forms-and-actions.md
  */
 
-import type { CacheHandler } from '#/cache/index';
-import { RedirectSignal } from './primitives';
-import { withSpan } from './tracing';
-import { revalidationAls, type RevalidationState } from './als-registry.js';
-
+import { cache } from '../cache/cache-api.ts';
+import { canonicalize } from './canonicalize.ts';
+import { isDenySignal, isRedirectSignal } from './primitives.ts';
+import { withSpan } from './tracing.ts';
+import { revalidationAls, type RevalidationState } from './als-registry.ts';
 // ─── Types ───────────────────────────────────────────────────────────────
 
-/** Result of rendering a revalidation — element tree before RSC serialization. */
+/** Result of rendering a revalidation — payload root before RSC serialization. */
 export interface RevalidationResult {
-  /** React element tree (pre-serialization — passed to renderToReadableStream). */
-  element: unknown;
-  /** Resolved head elements for metadata. */
-  headElements: unknown[];
+  /**
+   * The payload root — tree plus the params it rendered with, exactly as an
+   * ordinary route payload. The client splits it in `applyActionResult`.
+   */
+  payload: unknown;
 }
 
 /** Renderer function that builds a React element tree for a given path. */
 export type RevalidateRenderer = (path: string) => Promise<RevalidationResult>;
 
 // Re-export the type from the registry for public API consumers.
-export type { RevalidationState } from './als-registry.js';
+export type { RevalidationState } from './als-registry.ts';
 
 /** Options for creating the action handler. */
 export interface ActionHandlerConfig {
-  /** Cache handler for tag invalidation. */
-  cacheHandler?: CacheHandler;
   /** Renderer for producing RSC payloads during revalidation. */
   renderer?: RevalidateRenderer;
+  /**
+   * Pathname of the page the action was submitted from. When set,
+   * revalidatePath renders are skipped for non-matching paths — the
+   * server cache is already invalidated, so the next navigation fetches
+   * fresh data. See TIM-1454.
+   */
+  requestPathname?: string;
+  /** Search string of the action request URL (e.g. `?page=1`). */
+  requestSearch?: string;
 }
 
 /** Result of handling a server action request. */
@@ -49,6 +57,12 @@ export interface ActionHandlerResult {
   actionResult: unknown;
   /** Revalidation result if revalidatePath was called (element tree, not yet serialized). */
   revalidation?: RevalidationResult;
+  /**
+   * Paths passed to `revalidatePath()` that don't match the current page
+   * (TIM-1454). The client invalidates its caches for these so the next
+   * navigation fetches fresh data.
+   */
+  invalidatedPaths?: string[];
   /** Redirect location if a RedirectSignal was thrown during revalidation. */
   redirectTo?: string;
   /** Redirect status code. */
@@ -62,21 +76,11 @@ export interface ActionHandlerResult {
 // (the previous module-level global was vulnerable to cross-request pollution).
 
 /**
- * Set the revalidation state for the current action execution.
- * @internal — kept for test compatibility; prefer executeAction() which uses ALS.
- */
-export function _setRevalidationState(state: RevalidationState): void {
-  // Enter ALS scope — this is only used by tests that call revalidatePath/Tag
-  // directly without going through executeAction().
-  revalidationAls.enterWith(state);
-}
-
-/**
- * Clear the revalidation state after action execution.
- * @internal — kept for test compatibility.
+ * Run `fn` inside a revalidation ALS scope.
+ * @internal — for tests that call revalidatePath/Tag directly without executeAction().
  */
-export function _clearRevalidationState(): void {
-  revalidationAls.enterWith(undefined as unknown as RevalidationState);
+export function _runWithRevalidationState<T>(state: RevalidationState, fn: () => T): T {
+  return revalidationAls.run(state, fn);
 }
 
 /**
@@ -112,8 +116,8 @@ export function revalidatePath(path: string): void {
 }
 
 /**
- * Invalidate all pre-rendered shells and 'use cache' entries tagged with `tag`.
- * Does not return a payload — the next request for an invalidated route re-renders fresh.
+ * Invalidate all timber.cache entries tagged with `tag`.
+ * Does not return a payload — the next request for an invalidated entry re-executes.
  *
  * @param tag - The cache tag to invalidate (e.g. 'products', 'user:123').
  */
@@ -124,6 +128,13 @@ export function revalidateTag(tag: string): void {
   }
 }
 
+// ─── Helpers ────────────────────────────────────────────────────────────
+
+function stripFragment(path: string): string {
+  const idx = path.indexOf('#');
+  return idx >= 0 ? path.slice(0, idx) : path;
+}
+
 // ─── Action Handler ──────────────────────────────────────────────────────
 
 /**
@@ -163,7 +174,7 @@ export async function executeAction(
         () => actionFn(...args)
       );
     } catch (error) {
-      if (error instanceof RedirectSignal) {
+      if (isRedirectSignal(error)) {
         redirectTo = error.location;
         redirectStatus = error.status;
       } else {
@@ -172,27 +183,58 @@ export async function executeAction(
     }
   });
 
-  // Process tag invalidation
-  if (state.tags.length > 0 && config.cacheHandler) {
-    await Promise.all(state.tags.map((tag) => config.cacheHandler!.invalidate({ tag })));
+  // Process tag invalidation through cache.invalidate so it records the
+  // invalidation epoch — an in-flight cached fn must not re-store data this
+  // mutation just invalidated (TIM-1028). cache.invalidate resolves the
+  // module-level handler singleton: setCacheHandler() is called at boot from
+  // rsc-entry when timber.config.ts provides a cacheHandler; otherwise falls
+  // back to in-memory LRU (TIM-599).
+  if (state.tags.length > 0) {
+    // cache.invalidate handles both data-cache clearing AND component-seed
+    // tombstone writes (design/45 §ISR mechanics) — no separate tombstone
+    // step needed here.
+    // Best-effort: the action body already executed and its mutation committed.
+    // Use allSettled so all tags settle before proceeding — Promise.all would
+    // short-circuit on the first rejection, leaving other invalidations (including
+    // component-seed tombstone writes) in-flight during revalidatePath rendering.
+    const results = await Promise.allSettled(state.tags.map((tag) => cache.invalidate({ tag })));
+    for (const r of results) {
+      if (r.status === 'rejected') {
+        console.error('[timber] revalidateTag invalidation failed:', r.reason);
+      }
+    }
   }
 
-  // Process path revalidation — build element tree (not yet serialized)
+  // Process path revalidation — build element tree (not yet serialized).
+  //
+  // TIM-1454: Only render the path if it matches the current page. Non-matching
+  // paths are collected as `invalidatedPaths` — the client evicts them from its
+  // caches so the next navigation fetches fresh data.
   let revalidation: RevalidationResult | undefined;
-  if (state.paths.length > 0 && config.renderer) {
-    // For now, render the first revalidated path.
-    // Multiple paths could be supported via multipart streaming in the future.
+  let invalidatedPaths: string[] | undefined;
+
+  if (state.paths.length > 0) {
     const path = state.paths[0];
-    try {
-      revalidation = await config.renderer(path);
-    } catch (renderError) {
-      if (renderError instanceof RedirectSignal) {
-        // Revalidation triggered a redirect (e.g., session expired)
-        redirectTo = renderError.location;
-        redirectStatus = renderError.status;
-      } else {
-        // Log but don't fail the action — revalidation is best-effort
-        console.error('[timber] revalidatePath render failed:', renderError);
+
+    if (
+      config.requestPathname &&
+      !revalidationPathMatches(path, config.requestPathname, config.requestSearch)
+    ) {
+      invalidatedPaths = [stripFragment(path)];
+    } else if (config.renderer) {
+      try {
+        revalidation = await config.renderer(path);
+      } catch (renderError) {
+        if (isRedirectSignal(renderError)) {
+          redirectTo = renderError.location;
+          redirectStatus = renderError.status;
+        } else if (isDenySignal(renderError)) {
+          console.error(
+            `[timber] revalidatePath dropped — target middleware denied (status ${renderError.status})`
+          );
+        } else {
+          console.error('[timber] revalidatePath render failed:', renderError);
+        }
       }
     }
   }
@@ -200,31 +242,33 @@ export async function executeAction(
   return {
     actionResult,
     revalidation,
+    invalidatedPaths,
     ...(redirectTo ? { redirectTo, redirectStatus } : {}),
   };
 }
 
 /**
- * Build an HTTP Response for a no-JS form submission.
- * Standard POST → 302 redirect pattern.
- *
- * @param redirectPath - Where to redirect after the action executes.
- */
-export function buildNoJsResponse(redirectPath: string, status: number = 302): Response {
-  return new Response(null, {
-    status,
-    headers: { Location: redirectPath },
-  });
-}
-
+ * Check if a `revalidatePath(path)` argument matches the request pathname.
 /**
- * Detect whether the incoming request is an RSC action request (with JS)
- * or a plain HTML form POST (no JS).
- *
- * RSC action requests use Accept: text/x-component or Content-Type: text/x-component.
+ * Canonicalizes the revalidated path the same way the renderer does so
+ * equivalent paths compare equal. Returns true when the paths match or
+ * when comparison is inconclusive (validation failure → render to be safe).
  */
-export function isRscActionRequest(req: Request): boolean {
-  const accept = req.headers.get('Accept') ?? '';
-  const contentType = req.headers.get('Content-Type') ?? '';
-  return accept.includes('text/x-component') || contentType.includes('text/x-component');
+function revalidationPathMatches(
+  revalidatedPath: string,
+  requestPathname: string,
+  requestSearch?: string
+): boolean {
+  const hashIdx = revalidatedPath.indexOf('#');
+  const noFragment = hashIdx >= 0 ? revalidatedPath.slice(0, hashIdx) : revalidatedPath;
+  const queryIdx = noFragment.indexOf('?');
+  const pathnameOnly = queryIdx >= 0 ? noFragment.slice(0, queryIdx) : noFragment;
+  const search = queryIdx >= 0 ? noFragment.slice(queryIdx) : '';
+  const canonical = canonicalize(pathnameOnly, true);
+  if (!canonical.ok) return true;
+  if (canonical.pathname !== requestPathname) return false;
+  // revalidatePath('/dashboard') (no search) matches any query variant.
+  // revalidatePath('/dashboard?tab=x') only matches that exact search.
+  if (search && search !== (requestSearch ?? '')) return false;
+  return true;
 }

package/src/server/als-registry.ts

@@ -6,28 +6,66 @@
  * this registry and re-export public accessor functions.
  *
  * Why: ALS instances require singleton semantics — if two copies of the
- * same ALS exist (one from a relative import, one from a barrel import),
- * one module writes to its copy and another reads from an empty copy.
- * Centralizing ALS creation in a single module eliminates this class of bug.
+ * same ALS exist (one from a relative import, one from a barrel import,
+ * or the same file re-evaluated by Vite after an HMR invalidation), one
+ * module writes to its copy and another reads from an empty copy.
+ * Centralizing ALS creation in a single module + anchoring each instance
+ * on `globalThis` under a `Symbol.for(...)` key eliminates this class of
+ * bug, including the Vite-dev case where module instance split would
+ * otherwise hand two copies of this file out of a single evaluation cycle.
  *
- * The `timber-shims` plugin ensures `@timber-js/app/server` resolves to
- * src/ in RSC and SSR environments, so all import paths converge here.
+ * The `timber-shims` plugin remaps `@timber-js/app/server` to src/ in
+ * RSC and SSR environments so import-specifier paths converge here, and
+ * the `globalThis[SYMBOL_FOR]` anchor below closes the remaining gap: any
+ * second evaluation of this module picks up the ALS the first evaluation
+ * already stored rather than instantiating a fresh one. Same pattern the
+ * Cloudflare bindings ALS uses in `adapters/cloudflare.ts`.
  *
  * DO NOT create ALS instances outside this file. If you need a new ALS,
  * add it here and import from `./als-registry.js` in the consuming module.
+ * Inside this file, always route through `getOrCreateAls(symbol)` — a raw
+ * `new AsyncLocalStorage()` reintroduces the instance-split hazard.
  *
  * See design/18-build-system.md §"Module Singleton Strategy" and
- * §"Singleton State Registry".
+ * §"Singleton State Registry". Regression test:
+ * `tests/als-registry-singleton.test.ts`.
  */
 
+import '#server-only-guard';
+import type { CoercedParams } from '../shared/param-value.ts';
+import type { SlotParamsRecord } from '../shared/slot-params.ts';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import type { DebugComponentEntry } from './rsc-entry/helpers.ts';
+
+/**
+ * Return a process-wide singleton `AsyncLocalStorage` keyed by `symbol`.
+ *
+ * `Symbol.for(...)` keys live in the cross-realm symbol registry, and
+ * `globalThis` is shared across every module evaluation inside the same
+ * Node.js process. Together they give a stable anchor that survives
+ * re-evaluation of this file — the second evaluation observes the
+ * `globalThis[symbol]` slot already populated by the first and hands
+ * back the identical ALS instance.
+ */
+function getOrCreateAls<T>(symbol: symbol): AsyncLocalStorage<T> {
+  const g = globalThis as unknown as Record<symbol, unknown>;
+  const existing = g[symbol];
+  if (existing instanceof AsyncLocalStorage) {
+    return existing as AsyncLocalStorage<T>;
+  }
+  const created = new AsyncLocalStorage<T>();
+  g[symbol] = created;
+  return created;
+}
 
 // ─── Request Context ──────────────────────────────────────────────────────
-// Used by: request-context.ts (headers(), cookies(), searchParams())
+// Used by: request-context.ts (getHeaders(), getCookies(), getSearchParams())
 // Design doc: design/04-authorization.md
 
 /** @internal — import via request-context.ts public API */
-export const requestContextAls = new AsyncLocalStorage<RequestContextStore>();
+export const requestContextAls = getOrCreateAls<RequestContextStore>(
+  Symbol.for('timber:request-context-als')
+);
 
 export interface RequestContextStore {
   /** Incoming request headers (read-only view). */
@@ -39,28 +77,102 @@ export interface RequestContextStore {
   /** Original (pre-overlay) frozen headers, kept for overlay merging. */
   originalHeaders: Headers;
   /**
-   * Promise resolving to the route's typed search params (when search-params.ts
-   * exists) or to the raw URLSearchParams. Stored as a Promise so the framework
-   * can later support partial pre-rendering where param resolution is deferred.
+   * CSP nonce, created the first time middleware reads `ctx.nonce`. Read by
+   * the renderers via `getCspNonce()` and stamped on every inline script.
+   * Absent when no middleware asked for one. See server/csp-nonce.ts.
+   */
+  cspNonce?: string;
+  /**
+   * Raw URLSearchParams for the current request.
+   * To get typed parsed params, import a search params definition and
+   * call `.parse(searchParams())`.
+   */
+  searchParams: URLSearchParams;
+  /**
+   * Raw search string from the request URL (e.g. "?foo=bar&baz=1").
+   * Available synchronously for use in `redirect()` with `preserveSearchParams`.
+   */
+  searchString: string;
+  /**
+   * Coerced segment params for the current request.
+   * Set by the pipeline after route matching and param coercion, before
+   * middleware and rendering. Pages and layouts read params via
+   * `getSegmentParams()` instead of receiving them as a prop.
+   *
+   * See design/07-routing.md §"params.ts — Convention File for Typed Params"
+   */
+  segmentParams?: CoercedParams;
+  /**
+   * The matched segment path (e.g. '/(browse)/[artistSlug]/[year]').
+   * Includes route groups and parallel slots — uniquely identifies the
+   * segment in the route tree. Set by the pipeline alongside segmentParams.
+   * Used by getSegmentParams() for dev-mode validation.
+   * See design/41-global-params.md §Runtime Validation
+   */
+  matchedSegmentPath?: string;
+  /**
+   * Per-slot coerced segment params, keyed by the slot's full tree path
+   * (e.g. '/(browse)/@shows/[artistSlug]/[...year]').
+   *
+   * Each slot walks its own segment tree and may interpret URL parts
+   * differently from the main route (e.g. catch-all vs dynamic). This
+   * map stores slot-specific params so getSegmentParams(segmentPath)
+   * returns the correct types for slot pages.
+   *
+   * See design/07-routing.md §"Parallel Slot Params"
    */
-  searchParamsPromise: Promise<URLSearchParams | Record<string, unknown>>;
+  slotParams?: SlotParamsRecord;
   /** Outgoing Set-Cookie entries (name → serialized value + options). Last write wins. */
   cookieJar: Map<string, CookieEntry>;
   /** Whether the response has flushed (headers committed). */
   flushed: boolean;
   /** Whether the current context allows cookie mutation. */
   mutableContext: boolean;
+  /**
+   * Set by AccessGate or PageDenyBoundary when a DenySignal is caught
+   * server-side (inside the React tree, before React Flight sees it).
+   * The document path reads this after render to set the HTTP status code;
+   * the RSC payload path does not read it (a Flight payload response is always 200).
+   * See TIM-666, TIM-1495.
+   */
+  denyStatus?: number;
+  /**
+   * Dev-only: getter for the current request's RSC debug components.
+   * Set by renderRoute() so onPipelineError can include component tree
+   * context for render-phase errors without module-level shared state.
+   */
+  debugComponentsGetter?: () => DebugComponentEntry[];
+  /**
+   * Index of the first segment whose AccessGate denied during render.
+   * Recorded by AccessGate when it catches a DenySignal so post-render
+   * consumers (buildSegmentInfo, X-Timber-Segments header) can bound
+   * the segment list without a pre-render access pass. Infinity when
+   * no segment denied. See TIM-1363.
+   */
+  _firstDeniedSegmentIndex?: number;
+  /**
+   * Metadata entries collected during render by MetadataCollector.
+   * Populated per-segment in tree order (root→page) during
+   * renderToReadableStream. Entries may contain promises for dynamic
+   * metadata (resolved concurrently with page rendering, TIM-1367).
+   * MetadataHead awaits all entries before merging.
+   * See TIM-1363, TIM-1367, design/16-metadata.md.
+   */
+  _metadataEntries?: Array<{
+    metadata: import('./types.ts').Metadata | Promise<import('./types.ts').Metadata | null>;
+    isPage: boolean;
+  }>;
 }
 
 /** A single outgoing cookie entry in the cookie jar. */
 export interface CookieEntry {
   name: string;
   value: string;
-  options: import('./request-context.js').CookieOptions;
+  options: import('./cookie-context.ts').CookieOptions;
 }
 
 // ─── Tracing ──────────────────────────────────────────────────────────────
-// Used by: tracing.ts (traceId(), spanId())
+// Used by: tracing.ts (getTraceId(), getSpanId())
 // Design doc: design/17-logging.md
 
 export interface TraceStore {
@@ -68,21 +180,28 @@ export interface TraceStore {
   traceId: string;
   /** OTEL span ID if available, undefined otherwise. */
   spanId?: string;
+  /**
+   * Innermost active native platform span (e.g. Cloudflare's `Span` from
+   * tracing.enterSpan()). Tracked so setSpanAttribute() can set attributes
+   * after span creation — the platform API has no getActiveSpan() equivalent.
+   * Saved/restored by withSpan() around each callback. See TIM-1135.
+   */
+  platformSpan?: import('./tracing.ts').PlatformSpan;
 }
 
 /** @internal — import via tracing.ts public API */
-export const traceAls = new AsyncLocalStorage<TraceStore>();
+export const traceAls = getOrCreateAls<TraceStore>(Symbol.for('timber:trace-als'));
 
 // ─── Server-Timing ────────────────────────────────────────────────────────
 // Used by: server-timing.ts (recordTiming(), withTiming())
 // Design doc: (dev-only performance instrumentation)
 
 export interface TimingStore {
-  entries: import('./server-timing.js').TimingEntry[];
+  entries: import('./server-timing.ts').TimingEntry[];
 }
 
 /** @internal — import via server-timing.ts public API */
-export const timingAls = new AsyncLocalStorage<TimingStore>();
+export const timingAls = getOrCreateAls<TimingStore>(Symbol.for('timber:timing-als'));
 
 // ─── Revalidation ─────────────────────────────────────────────────────────
 // Used by: actions.ts (revalidatePath(), revalidateTag())
@@ -96,14 +215,18 @@ export interface RevalidationState {
 }
 
 /** @internal — import via actions.ts public API */
-export const revalidationAls = new AsyncLocalStorage<RevalidationState>();
+export const revalidationAls = getOrCreateAls<RevalidationState>(
+  Symbol.for('timber:revalidation-als')
+);
 
 // ─── Form Flash ───────────────────────────────────────────────────────────
 // Used by: form-flash.ts (getFormFlash())
 // Design doc: design/08-forms-and-actions.md §"No-JS Error Round-Trip"
 
 /** @internal — import via form-flash.ts public API */
-export const formFlashAls = new AsyncLocalStorage<import('./form-flash.js').FormFlashData>();
+export const formFlashAls = getOrCreateAls<import('./form-flash.ts').FormFlashData>(
+  Symbol.for('timber:form-flash-als')
+);
 
 // ─── Early Hints Sender ──────────────────────────────────────────────────
 // Used by: early-hints-sender.ts (sendEarlyHints103())
@@ -113,7 +236,9 @@ export const formFlashAls = new AsyncLocalStorage<import('./form-flash.js').Form
 export type EarlyHintsSenderFn = (links: string[]) => void;
 
 /** @internal — import via early-hints-sender.ts public API */
-export const earlyHintsSenderAls = new AsyncLocalStorage<EarlyHintsSenderFn>();
+export const earlyHintsSenderAls = getOrCreateAls<EarlyHintsSenderFn>(
+  Symbol.for('timber:early-hints-sender-als')
+);
 
 // ─── waitUntil Bridge ────────────────────────────────────────────────────
 // Used by: waituntil-bridge.ts (waitUntil())
@@ -123,4 +248,18 @@ export const earlyHintsSenderAls = new AsyncLocalStorage<EarlyHintsSenderFn>();
 export type WaitUntilFn = (promise: Promise<unknown>) => void;
 
 /** @internal — import via waituntil-bridge.ts public API */
-export const waitUntilAls = new AsyncLocalStorage<WaitUntilFn>();
+export const waitUntilAls = getOrCreateAls<WaitUntilFn>(Symbol.for('timber:wait-until-als'));
+
+// ─── Workers Cache Purge Bridge ─────────────────────────────────────────
+// Used by: workers-cache-bridge.ts (runWithWorkersCachePurge())
+// Design doc: design/06-caching.md, design/25-production-deployments.md
+
+/** Workers Cache purge function from Cloudflare ExecutionContext.cache. */
+export interface WorkersCachePurgeCtx {
+  purge(opts: { tags: string[] }): Promise<void>;
+}
+
+/** @internal — import via workers-cache-bridge.ts public API */
+export const workersCachePurgeAls = getOrCreateAls<WorkersCachePurgeCtx>(
+  Symbol.for('timber:workers-cache-purge-als')
+);

package/src/server/asset-headers.ts

@@ -8,13 +8,25 @@
  * Unhashed assets (e.g. /favicon.ico) get a shorter cache with revalidation:
  *   Cache-Control: public, max-age=3600, must-revalidate
  *
- * This is applied automatically by the framework for static assets served
- * from the build output. Page responses are NOT affected — those are
- * controlled by the developer via middleware.ts or proxy.ts.
+ * The `_headers` file lists hashed asset paths (/assets/*, /_timber/fonts/*) as
+ * wildcard rules and unhashed files as per-file rules. At runtime, adapters
+ * that see static file requests (nitro, preview) also set Cache-Control via
+ * `getAssetCacheControl()`. On Cloudflare Workers Static Assets, the worker
+ * never sees static file requests — the `_headers` file is the only mechanism.
+ * Page responses are NOT affected — those are controlled by the developer
+ * via middleware.ts or proxy.ts.
  *
  * Design docs: 18-build-system.md, 06-caching.md
  */
 
+import { IMMUTABLE_CACHE, STATIC_CACHE } from '../adapters/shared.ts';
+
+// Re-export cache constants and generateHeadersFile from the shared adapter
+// module. The canonical definitions live in adapters/shared.ts because
+// adapters are loaded by Node before Vite's resolver is available — they
+// can only import from within their own directory.
+export { IMMUTABLE_CACHE, STATIC_CACHE, generateHeadersFile } from '../adapters/shared.ts';
+
 /**
  * Regex matching Vite-hashed asset filenames.
  *
@@ -30,18 +42,6 @@
  */
 const HASHED_ASSET_RE = /[-.][\da-f]{8,}\.\w+$/;
 
-/** One year in seconds (365 days). */
-const ONE_YEAR = 31_536_000;
-
-/** One hour in seconds. */
-const ONE_HOUR = 3_600;
-
-/** Cache-Control value for hashed (immutable) assets. */
-export const IMMUTABLE_CACHE = `public, max-age=${ONE_YEAR}, immutable`;
-
-/** Cache-Control value for unhashed static assets. */
-export const STATIC_CACHE = `public, max-age=${ONE_HOUR}, must-revalidate`;
-
 /**
  * Check if a URL path looks like a hashed asset.
  */
@@ -57,25 +57,3 @@ export function isHashedAsset(pathname: string): boolean {
 export function getAssetCacheControl(pathname: string): string {
   return isHashedAsset(pathname) ? IMMUTABLE_CACHE : STATIC_CACHE;
 }
-
-/**
- * Generate a `_headers` file for static asset cache control.
- *
- * The `_headers` file is a platform convention supported by Cloudflare Workers
- * Static Assets, Cloudflare Pages, and Netlify. It maps URL patterns to
- * HTTP response headers.
- *
- * Vite places all hashed chunks under `/assets/` — these get immutable caching.
- * Everything else (favicon.ico, robots.txt, etc.) gets a shorter cache.
- */
-export function generateHeadersFile(): string {
-  return `# Auto-generated by @timber-js/app — static asset cache headers.
-# See design/25-production-deployments.md §"CDN / Edge Cache"
-
-/assets/*
-  Cache-Control: ${IMMUTABLE_CACHE}
-
-/*
-  Cache-Control: ${STATIC_CACHE}
-`;
-}

package/src/server/body-limits.ts

@@ -53,6 +53,9 @@ export function parseBodySize(size: string): number {
   }
 }
 
+/** Strict integer pattern: one or more digits, nothing else. */
+const STRICT_INTEGER_RE = /^\d+$/;
+
 /** Check whether a request body exceeds the configured size limit (stateless, no ALS). */
 export function enforceBodyLimits(
   req: Request,
@@ -66,11 +69,16 @@ export function enforceBodyLimits(
     return { ok: false, status: 411 };
   }
 
-  const bodySize = Number.parseInt(contentLength, 10);
-  if (Number.isNaN(bodySize)) {
+  // Reject malformed values: multiple values ("100, 999999"), negative numbers,
+  // floats ("100.5"), or non-numeric strings. parseInt would silently parse
+  // the first number from "100, 999999" as 100, letting the real body through.
+  const trimmed = contentLength.trim();
+  if (!STRICT_INTEGER_RE.test(trimmed)) {
     return { ok: false, status: 411 };
   }
 
+  const bodySize = Number.parseInt(trimmed, 10);
+
   const limit = resolveLimit(kind, config);
   return bodySize <= limit ? { ok: true } : { ok: false, status: 413 };
 }