@timber-js/app 0.1.25 → 0.1.27

package/dist/plugins/server-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-bundle.d.ts","sourceRoot":"","sources":["../../src/plugins/server-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CA0G7C"}
+{"version":3,"file":"server-bundle.d.ts","sourceRoot":"","sources":["../../src/plugins/server-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAyH7C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timber-js/app",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Vite-native React framework for Cloudflare Workers — correct HTTP semantics, real status codes, pages that work without JavaScript",
   "keywords": [
     "cloudflare-workers",

package/src/adapters/nitro.ts

@@ -213,9 +213,15 @@ export function nitro(options: NitroAdapterOptions = {}): TimberPlatformAdapter
     // local runtime — Vite's built-in preview is the fallback.
     preview: LOCALLY_PREVIEWABLE.has(preset)
       ? async (_config: TimberConfig, buildDir: string) => {
-          const cmd = generateNitroPreviewCommand(buildDir, preset);
-          if (!cmd) return;
-          await spawnNitroPreview(cmd.command, cmd.args, cmd.cwd);
+          // Generate a standalone preview server that uses Node's built-in
+          // HTTP server. The Nitro entry.ts can't be run directly because
+          // it imports h3 (a Nitro dependency not available at runtime).
+          const previewScript = generatePreviewScript(buildDir, preset);
+          const scriptPath = join(buildDir, 'nitro', '_preview-server.mjs');
+          await writeFile(scriptPath, previewScript);
+
+          const command = preset === 'bun' ? 'bun' : 'node';
+          await spawnNitroPreview(command, [scriptPath], join(buildDir, 'nitro'));
         }
       : undefined,
 
@@ -320,6 +326,175 @@ export default defineNitroConfig(${configJson})
 /** Presets that produce a locally-runnable server entry. */
 const LOCALLY_PREVIEWABLE = new Set<NitroPreset>(['node-server', 'bun']);
 
+/**
+ * Generate a standalone preview server script that uses Node's built-in
+ * HTTP server. This bypasses Nitro entirely — the Nitro entry.ts imports
+ * h3 which isn't available outside a Nitro build. For local preview we
+ * just need to serve static files and route requests to the RSC handler.
+ *
+ * @internal Exported for testing.
+ */
+export function generatePreviewScript(buildDir: string, preset: NitroPreset): string {
+  const rscEntryRelative = relative(join(buildDir, 'nitro'), join(buildDir, 'rsc', 'index.js'));
+  const rscEntry = rscEntryRelative.startsWith('.') ? rscEntryRelative : './' + rscEntryRelative;
+  const publicDir = './public';
+  const manifestInitPath = './_timber-manifest-init.js';
+  const runtimeName = PRESET_CONFIGS[preset].runtimeName;
+
+  return `// Generated by @timber-js/app — standalone preview server.
+// Uses Node's built-in HTTP server to serve static assets and route
+// dynamic requests through the RSC handler. No Nitro/h3 dependency.
+
+import { createServer } from 'node:http';
+import { readFile, stat } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+
+// Set runtime before importing the handler.
+process.env.TIMBER_RUNTIME = '${runtimeName}';
+
+// Load the build manifest if it exists.
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const manifestPath = join(__dirname, '${manifestInitPath}');
+if (existsSync(manifestPath)) {
+  await import('${manifestInitPath}');
+}
+
+// Import the RSC handler (default export is the fetch-like handler).
+const { default: handler, runWithEarlyHintsSender } = await import('${rscEntry}');
+
+const MIME_TYPES = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.webm': 'video/webm',
+  '.mp4': 'video/mp4',
+  '.txt': 'text/plain',
+  '.xml': 'application/xml',
+  '.wasm': 'application/wasm',
+};
+
+const publicDir = join(__dirname, '${publicDir}');
+const port = parseInt(process.env.PORT || '3000', 10);
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url || '/', \`http://localhost:\${port}\`);
+
+  // Try serving static files from the public directory first.
+  const filePath = join(publicDir, url.pathname);
+  // Prevent path traversal.
+  if (filePath.startsWith(publicDir)) {
+    try {
+      const fileStat = await stat(filePath);
+      if (fileStat.isFile()) {
+        const ext = extname(filePath);
+        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+        const body = await readFile(filePath);
+        // Hashed assets get immutable cache, others get short cache.
+        const cacheControl = url.pathname.startsWith('/assets/')
+          ? 'public, max-age=31536000, immutable'
+          : 'public, max-age=3600, must-revalidate';
+        res.writeHead(200, {
+          'Content-Type': contentType,
+          'Content-Length': body.length,
+          'Cache-Control': cacheControl,
+        });
+        res.end(body);
+        return;
+      }
+    } catch {
+      // File not found — fall through to the RSC handler.
+    }
+  }
+
+  // Convert Node request to Web Request.
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) {
+      if (Array.isArray(value)) {
+        for (const v of value) headers.append(key, v);
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+
+  let body = undefined;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    body = await new Promise((resolve) => {
+      const chunks = [];
+      req.on('data', (chunk) => chunks.push(chunk));
+      req.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+  }
+
+  const webRequest = new Request(url.href, {
+    method: req.method,
+    headers,
+    body,
+    duplex: body ? 'half' : undefined,
+  });
+
+  try {
+    // Support 103 Early Hints when available.
+    const earlyHintsSender = (typeof res.writeEarlyHints === 'function')
+      ? (links) => { try { res.writeEarlyHints({ link: links }); } catch {} }
+      : undefined;
+
+    const webResponse = earlyHintsSender && runWithEarlyHintsSender
+      ? await runWithEarlyHintsSender(earlyHintsSender, () => handler(webRequest))
+      : await handler(webRequest);
+
+    // Write the response back to the Node response.
+    res.writeHead(webResponse.status, Object.fromEntries(webResponse.headers.entries()));
+
+    if (webResponse.body) {
+      const reader = webResponse.body.getReader();
+      const pump = async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) { res.end(); return; }
+          res.write(value);
+        }
+      };
+      await pump();
+    } else {
+      res.end();
+    }
+  } catch (err) {
+    console.error('[timber preview] Request error:', err);
+    if (!res.headersSent) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+    }
+    res.end('Internal Server Error');
+  }
+});
+
+server.listen(port, () => {
+  console.log();
+  console.log('  ⚡ timber preview server running at:');
+  console.log();
+  console.log(\`    ➜  http://localhost:\${port}\`);
+  console.log();
+});
+`;
+}
+
 /** Command descriptor for Nitro preview — testable without spawning. */
 export interface NitroPreviewCommand {
   command: string;

package/src/cli.ts

@@ -132,7 +132,7 @@ export async function runPreview(options: CommandOptions): Promise<void> {
   const adapter = config?.adapter as import('./adapters/types').TimberPlatformAdapter | undefined;
 
   if (resolvePreviewStrategy(adapter) === 'adapter') {
-    const buildDir = join(root, '.timber', 'build');
+    const buildDir = join(root, 'dist');
     const timberConfig = { output: (config?.output ?? 'server') as 'server' | 'static' };
     await adapter!.preview!(timberConfig, buildDir);
     return;

package/src/plugins/server-bundle.ts

@@ -95,10 +95,20 @@ export function timberServerBundle(): Plugin[] {
   // the variable assignment of the init function — so the module's React
   // imports, context creation, etc. never execute.
   //
-  // The fix: patch the `__esmMin` runtime definition to eagerly execute
-  // the init callback while still returning the lazy wrapper. This makes
-  // all ESM module inits run at load time (standard ESM behavior) instead
-  // of lazily, which is functionally correct and avoids the dropped-init bug.
+  // The fix: patch `__esmMin` to eagerly *attempt* each init, but fall
+  // back to lazy retry on failure. This handles two failure modes:
+  //
+  // 1. Forward references (e.g. Zod v4): `init_iso` calls `init_schemas`
+  //    which hasn't been defined yet. Eager execution fails, but when the
+  //    function is called lazily later, all dependencies are available.
+  //
+  // 2. Optional peer dep shims (e.g. @emotion/is-prop-valid for
+  //    framer-motion): Vite generates shims that throw for missing
+  //    optional deps. The throw is deferred to lazy execution where
+  //    the consuming package's try/catch handles it.
+  //
+  // The key: on failure, `fn` is NOT cleared, so the next call retries.
+  // On success, `fn` is set to 0 so subsequent calls are no-ops.
   const esmInitFixPlugin: Plugin = {
     name: 'timber-esm-init-fix',
     applyToEnvironment(environment) {
@@ -108,11 +118,16 @@ export function timberServerBundle(): Plugin[] {
       const lazy = 'var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);';
       if (!code.includes(lazy)) return null;
 
-      // Replace with eager-then-lazy: execute init immediately, then
-      // return the lazy wrapper for any subsequent calls (which are
-      // idempotent since fn is set to 0 after first execution).
-      const eager =
-        'var __esmMin = (fn, res) => { var l = () => (fn && (res = fn(fn = 0)), res); l(); return l; };';
+      // Eager-with-retry: attempt init immediately. On success, mark done
+      // (fn = 0). On failure, leave fn intact so the lazy wrapper retries
+      // on next call — by then forward dependencies are initialized.
+      const eager = [
+        'var __esmMin = (fn, res) => {',
+        '  var l = () => { if (fn) { var f = fn; try { res = f(); fn = 0; } catch(e) {} } return res; };',
+        '  l();',
+        '  return l;',
+        '};',
+      ].join(' ');
 
       return { code: code.replace(lazy, eager), map: null };
     },