@timber-js/app 0.2.0-alpha.149 → 0.2.0-alpha.150

package/dist/plugins/fonts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../../src/plugins/fonts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA2B1D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAsMtD"}
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../../src/plugins/fonts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA2B1D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAkLtD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timber-js/app",
-  "version": "0.2.0-alpha.149",
+  "version": "0.2.0-alpha.150",
   "description": "Vite-native React framework built for Servers and Serverless Platforms — correct HTTP semantics, real status codes, pages that work without JavaScript",
   "keywords": [
     "cloudflare-workers",

package/src/index.ts

@@ -325,14 +325,20 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
           envPort: process.env.PORT,
           listen: (p) => holdingRef.listen(p),
         });
-        resolvedDevPort = result.port;
-        resolvedDevPortExplicit = result.explicit;
         if (!result.bound) {
           // Holding server failed to bind. Drop the reference so the
           // dev-server plugin doesn't try to close a server that was
-          // never listening, and let Vite surface the conflict.
+          // never listening.
           ctx.holdingServer = null;
         }
+        if (result.bound || result.explicit) {
+          // When bound, use the probed port with strictPort so Vite
+          // doesn't re-bump. When unbound but explicit, still forward
+          // the port so Vite surfaces the conflict via strictPort.
+          // When unbound and implicit, skip — let Vite auto-bump.
+          resolvedDevPort = result.port;
+          resolvedDevPortExplicit = result.explicit;
+        }
       } else if (command === 'serve' && isPreview) {
         // Preview mode: resolve the starting port from config/env/
         // default but do NOT probe. Vite's preview server handles the

package/src/plugins/fonts.ts

@@ -143,8 +143,11 @@ export function timberFonts(ctx: PluginContext): Plugin {
      * emitted as a real CSS asset and @vitejs/plugin-rsc's `collectCss`
      * walks the RSC module graph to find it.
      *
-     * In dev mode we also lazily resolve Google `@font-face` descriptors
-     * from the CDN here, since `buildStart` is a no-op in dev.
+     * Google `@font-face` descriptors are resolved lazily here (both
+     * dev and production) because `load` runs after `transform` has
+     * registered the font. `buildStart` runs before any transforms,
+     * so fonts aren't in the pipeline yet when it fires for the first
+     * environment.
      */
     async load(id: string) {
       if (id === RESOLVED_GOOGLE) return generateGoogleVirtualModule(pipeline.fonts());
@@ -153,31 +156,32 @@ export function timberFonts(ctx: PluginContext): Plugin {
       if (pipeline.cssIdMap.matches(id)) {
         const importer = pipeline.cssIdMap.importerFor(id);
         if (!importer) {
-          // Hash is valid but no importer is registered — return an empty
-          // CSS module rather than `null`. This can happen if Vite's
-          // module graph invalidates the virtual module between the
-          // transform that registered the hash and the load that asks
-          // for it (e.g. after an HMR edit that removes every font from
-          // the file). An empty stylesheet is a valid, safe no-op.
           return '';
         }
 
-        if (ctx.dev) {
-          for (const font of pipeline.googleFonts()) {
-            if (font.importer !== importer) continue;
-            if (pipeline.hasFaces(font.id)) continue;
-            try {
+        for (const font of pipeline.googleFonts()) {
+          if (font.importer !== importer) continue;
+          if (pipeline.hasFaces(font.id)) continue;
+          try {
+            if (ctx.dev) {
               const faces = await resolveDevFontFaces(font);
               pipeline.attachFaces(font.id, faces);
-            } catch (e) {
-              // Fail gracefully — fonts fall back to system fonts. Don't
-              // cache the failure so transient errors (network blips, rate
-              // limits) are retried on the next request. See TIM-636.
-              const msg = e instanceof Error ? e.message : String(e);
-              console.warn(
-                `[timber-fonts] Failed to resolve Google font "${font.family}": ${msg}. Will retry on next request.`
+            } else {
+              const cached = await downloadAndCacheFonts([font], ctx.root);
+              const byFamily = groupCachedFontsByFamily(cached);
+              const familyCached = byFamily.get(font.family.toLowerCase()) ?? [];
+              pipeline.attachCachedFiles(font.id, familyCached);
+              pipeline.attachFaces(
+                font.id,
+                generateProductionFontFaces(familyCached, font.display, fontUrlPrefix(resolvedBase))
               );
             }
+          } catch (e) {
+            if (!ctx.dev) throw e;
+            const msg = e instanceof Error ? e.message : String(e);
+            console.warn(
+              `[timber-fonts] Failed to resolve Google font "${font.family}": ${msg}. Will retry on next request.`
+            );
           }
         }
 
@@ -196,39 +200,15 @@ export function timberFonts(ctx: PluginContext): Plugin {
     },
 
     /**
-     * Download and cache Google Fonts during production builds.
-     *
-     * In dev mode this is a no-op — fonts point to the Google CDN and are
-     * resolved lazily inside `load()` when the side-effect module runs.
+     * No-op. Font downloading and face attachment happen lazily in `load()`
+     * because `buildStart` runs before `transform` — fonts aren't registered
+     * in the pipeline yet when this fires for the first environment.
      *
      * Local font hashing is handled at registration time by the pipeline
      * (when `hashOnRegister` is set) so hashed filenames are available
      * before the virtual CSS `load()` hook runs.
      */
-    async buildStart() {
-      if (ctx.dev) return;
-
-      const googleFonts = [...pipeline.googleFonts()];
-      if (googleFonts.length === 0) return;
-
-      const cachedFonts = await downloadAndCacheFonts(googleFonts, ctx.root);
-
-      // Build a family→CachedFont[] lookup, then attach the cached files
-      // and resolved @font-face descriptors to each registered Google
-      // font. Multiple fonts that share a family hold references to the
-      // same `CachedFont` objects; the bundle emitter dedupes by
-      // `hashedFilename` so each binary is written to disk exactly once.
-      const cachedByFamily = groupCachedFontsByFamily(cachedFonts);
-      const urlPrefix = fontUrlPrefix(resolvedBase);
-      for (const font of googleFonts) {
-        const familyCached = cachedByFamily.get(font.family.toLowerCase()) ?? [];
-        pipeline.attachCachedFiles(font.id, familyCached);
-        pipeline.attachFaces(
-          font.id,
-          generateProductionFontFaces(familyCached, font.display, urlPrefix)
-        );
-      }
-    },
+    buildStart() {},
 
     /**
      * Scan source files for font function calls and extract static config.