@timber-js/app 0.1.29 → 0.1.30

package/dist/index.js

@@ -1,6 +1,6 @@
 import { r as setViteServer, t as formatSize } from "./_chunks/format-DNt20Kt8.js";
 import { i as scanRoutes, n as generateRouteMap, t as collectInterceptionRewrites } from "./_chunks/interception-DGDIjDbR.js";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
@@ -12748,7 +12748,8 @@ function detectDynamicFontCallAst(source, importedNames) {
 	} catch {
 		return null;
 	}
-	return walkForDynamicCalls(ast, new Set(importedNames), source);
+	const nameSet = new Set(importedNames);
+	return walkForDynamicCalls(ast, nameSet, source);
 }
 /**
 * Recursively walk the AST looking for CallExpression nodes where
@@ -14067,14 +14068,119 @@ function timberReactProd() {
 //#endregion
 //#region src/plugins/chunks.ts
 /**
+* timber-chunks — Vite sub-plugin for intelligent client chunk splitting.
+*
+* Splits client bundles into cache tiers based on update frequency:
+*
+* Tier 1: vendor-react    — react, react-dom, scheduler (changes rarely)
+* Tier 2: vendor-timber   — timber runtime, RSC runtime (changes per framework update)
+* Tier 3: vendor-app      — user node_modules (changes on dependency updates)
+* Tier 4: shared-app      — small shared app utilities/components (< 5KB source)
+* Tier 5: [route]-*       — per-route page/layout chunks (default Rollup splitting)
+*
+* The shared-app tier prevents tiny utility modules (constants, helpers,
+* small UI components) from becoming individual chunks when shared across
+* routes. Without this, Rolldown creates per-module chunks for any code
+* shared between two or more entry points, producing many sub-1KB chunks.
+*
+* Server environments (RSC, SSR) are left to Vite's default chunking since
+* Cloudflare Workers load all code from a single deployment bundle with no
+* benefit from cache-tier separation.
+*
+* Design docs: 27-chunking-strategy.md
+*/
+/**
+* Source file size threshold for the shared-app chunk.
+* Modules under this size that aren't route files get merged into shared-app
+* instead of getting their own tiny chunks.
+*/
+var SMALL_MODULE_THRESHOLD = 5 * 1024;
+/**
+* Route convention file basenames (without extension).
+* These files define route segments and must stay in per-route chunks
+* to preserve route-based code splitting.
+*/
+var ROUTE_FILE_BASENAMES = new Set([
+	"page",
+	"layout",
+	"loading",
+	"error",
+	"not-found",
+	"template",
+	"access",
+	"middleware",
+	"default",
+	"route"
+]);
+/**
+* Cache for source file sizes to avoid repeated statSync calls.
+* Populated lazily during the build.
+*/
+var sizeCache = /* @__PURE__ */ new Map();
+/**
+* Get the source file size, with caching.
+* Returns Infinity for virtual modules or files that can't be stat'd.
+*/
+function getSourceSize(id) {
+	const cached = sizeCache.get(id);
+	if (cached !== void 0) return cached;
+	try {
+		const size = statSync(id).size;
+		sizeCache.set(id, size);
+		return size;
+	} catch {
+		sizeCache.set(id, Infinity);
+		return Infinity;
+	}
+}
+/**
+* Extract the basename without extension from a module ID.
+* e.g. '/project/app/dashboard/page.tsx' → 'page'
+*/
+function getBasename(id) {
+	const lastSlash = id.lastIndexOf("/");
+	const filename = lastSlash >= 0 ? id.substring(lastSlash + 1) : id;
+	const dotIndex = filename.indexOf(".");
+	return dotIndex >= 0 ? filename.substring(0, dotIndex) : filename;
+}
+/**
+* Check if a module is a React ecosystem package (tier 1).
+*/
+function isReactVendor(id) {
+	return id.includes("node_modules/react-dom") || id.includes("node_modules/react/") || id.includes("node_modules/scheduler");
+}
+/**
+* Check if a module is part of the timber framework runtime (tier 2).
+*/
+function isTimberRuntime(id) {
+	return id.includes("/timber-app/") || id.includes("react-server-dom") || id.includes("@vitejs/plugin-rsc");
+}
+/**
+* Check if a module is a user-installed node_modules dependency (tier 3).
+* Excludes React ecosystem and timber runtime packages which have their own tiers.
+*/
+function isUserVendor(id) {
+	return id.includes("node_modules/") && !isReactVendor(id) && !isTimberRuntime(id);
+}
+/**
+* Check if a module is a route convention file that should stay per-route.
+*/
+function isRouteFile(id) {
+	return ROUTE_FILE_BASENAMES.has(getBasename(id));
+}
+/**
 * Categorize a module ID into a cache tier chunk name.
 *
-* Returns a chunk name for vendor modules, or undefined to let
-* Rollup's default splitting handle app/route code.
+* Returns a chunk name for vendor modules and small shared app code,
+* or undefined to let Rollup's default splitting handle route code.
 */
 function assignChunk(id) {
-	if (id.includes("node_modules/react-dom") || id.includes("node_modules/react/") || id.includes("node_modules/scheduler")) return "vendor-react";
-	if (id.includes("/timber-app/") || id.includes("react-server-dom") || id.includes("@vitejs/plugin-rsc")) return "vendor-timber";
+	if (isReactVendor(id)) return "vendor-react";
+	if (isTimberRuntime(id)) return "vendor-timber";
+	if (isUserVendor(id)) return "vendor-app";
+	if (!id.includes("\0") && id.startsWith("/") && !isRouteFile(id)) {
+		if (getSourceSize(id) < SMALL_MODULE_THRESHOLD) return "shared-app";
+	}
 }
 /**
 * Group timber's internal 'use client' modules into the vendor-timber chunk.
@@ -14082,10 +14188,17 @@ function assignChunk(id) {
 * The RSC plugin creates separate entry points for each 'use client' module,
 * which manualChunks can't merge. This function is passed as the RSC plugin's
 * `clientChunks` callback to group timber internals into a single chunk.
-* User and third-party client components are left to default per-route splitting.
+*
+* User client components that are small (< 5KB) are grouped into shared-client
+* to prevent thin facade wrappers from becoming individual chunks. This handles
+* the RSC client reference facade problem where each 'use client' module gets
+* a ~100-300 byte re-export wrapper chunk.
 */
 function assignClientChunk(meta) {
 	if (meta.id.includes("/timber-app/")) return "vendor-timber";
+	if (!meta.id.includes("\0") && meta.id.startsWith("/")) {
+		if (getSourceSize(meta.id) < SMALL_MODULE_THRESHOLD) return "shared-client";
+	}
 }
 /**
 * Create the timber-chunks Vite plugin.