@timber-js/app 0.2.0-alpha.95 → 0.2.0-alpha.96

package/dist/client/internal.js

@@ -1,8 +1,8 @@
 import { t as bindUseQueryStates } from "../_chunks/use-query-states-BiV5GJgm.js";
-import { n as getSsrData, r as setSsrData, t as clearSsrData } from "../_chunks/ssr-data-DzuI0bIV.js";
+import { a as getSsrData, i as clearSsrData, n as getRouterOrNull, o as setSsrData, r as setGlobalRouter, t as getRouter } from "../_chunks/router-ref-C8OCm7g7.js";
 import { TimberErrorBoundary } from "./error-boundary.js";
 import { n as useSegmentContext, t as SegmentProvider } from "../_chunks/segment-context-fHFLF1PE.js";
-import { a as getNavigationState, f as getRouter, i as NavigationProvider, m as setGlobalRouter, o as setNavigationState, p as getRouterOrNull, r as setHardNavigating, t as setCurrentParams } from "../_chunks/use-params-Br9YSUFV.js";
+import { a as getNavigationState, i as NavigationProvider, o as setNavigationState, r as setHardNavigating, t as setCurrentParams } from "../_chunks/use-params-IOPu7E8t.js";
 import { cloneElement, isValidElement } from "react";
 //#region src/client/segment-cache.ts
 /**

package/dist/fonts/pipeline.d.ts

@@ -27,6 +27,7 @@
  */
 import type { ExtractedFont, FontEntry, FontFaceDescriptor } from './types.js';
 import type { CachedFont } from './google.js';
+import { VirtualFontCssIdMap } from './virtual-modules.js';
 /**
  * Backwards-compatible alias for the registry shape that the standalone
  * `pruneRegistryEntries` and `generateAllFontCss` helpers operate on.
@@ -48,6 +49,17 @@ export declare class FontPipeline {
      * the map contents are mutable through the methods below.
      */
     private readonly _entries;
+    /**
+     * Per-importer virtual CSS module id registry. Populated by the
+     * transform hook when it inlines a font function call, read by the
+     * plugin's `load` hook when Vite asks for the module's CSS source.
+     *
+     * Lives on the pipeline (rather than a module-level singleton) so
+     * multiple parallel plugin instances — e.g. in the test suite — cannot
+     * collide on the hash-to-importer map. Also makes `clear()` reset the
+     * id map alongside the font entries so test fixtures start clean.
+     */
+    readonly cssIdMap: VirtualFontCssIdMap;
     /** Number of registered fonts. */
     size(): number;
     /** Iterate every entry as a `FontEntry` (with `faces` / `cachedFiles`). */
@@ -124,6 +136,23 @@ export declare class FontPipeline {
      * or lazily in `load` for dev).
      */
     getCss(): string;
+    /**
+     * Render the combined CSS for every font registered from a specific
+     * importer file. This is the anchor point for the per-importer virtual
+     * CSS module (`virtual:timber-font-css/<hash>.css`) that the transform
+     * hook injects as a side-effect import.
+     *
+     * Scoping by importer means two concurrent requests rendering different
+     * routes cannot see each other's font CSS: each importer's virtual
+     * module only contains CSS for fonts that module registered. It also
+     * means Vite's CSS HMR can surgically reload just the affected importer
+     * when a single file changes, rather than rebuilding one giant blob.
+     *
+     * Returns an empty string when no fonts are registered under `importer`.
+     * The empty string is semantically equivalent to "no CSS" — Vite's CSS
+     * pipeline handles it as a valid empty CSS module.
+     */
+    getCssForSegment(importer: string): string;
 }
 /**
  * Drop every registry entry that originated from `importer` and shares

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

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/fonts/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEtD,qBAAa,YAAY;IACvB;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;IAIzD,kCAAkC;IAClC,IAAI,IAAI,MAAM;IAId,2EAA2E;IAC3E,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAItC,uEAAuE;IACvE,KAAK,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAIxC,2CAA2C;IAC1C,WAAW,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAM3C,kCAAkC;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI3C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAKjC;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAOvC;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI;IAOxC,oEAAoE;IACpE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,EAAE,GAAG,IAAI;IAW9D,8DAA8D;IAC9D,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI;IAW5D;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAShD,mEAAmE;IACnE,KAAK,IAAI,IAAI;IAMb;;;;;OAKG;IACF,iBAAiB,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAYlD;;;;;;;OAOG;IACH,MAAM,IAAI,MAAM;CAOjB;AAoCD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,IAAI,CAON"}
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/fonts/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEtD,qBAAa,YAAY;IACvB;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;IAEzD;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,sBAA6B;IAI9C,kCAAkC;IAClC,IAAI,IAAI,MAAM;IAId,2EAA2E;IAC3E,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAItC,uEAAuE;IACvE,KAAK,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAIxC,2CAA2C;IAC1C,WAAW,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAM3C,kCAAkC;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI3C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAKjC;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAOvC;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI;IAOxC,oEAAoE;IACpE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,EAAE,GAAG,IAAI;IAW9D,8DAA8D;IAC9D,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI;IAW5D;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAShD,mEAAmE;IACnE,KAAK,IAAI,IAAI;IAOb;;;;;OAKG;IACF,iBAAiB,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAYlD;;;;;;;OAOG;IACH,MAAM,IAAI,MAAM;IAQhB;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;CAQ3C;AAoCD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,IAAI,CAON"}

package/dist/fonts/transform.d.ts

@@ -56,14 +56,6 @@ export declare function parseGoogleFontFamilies(source: string): Map<string, str
 export declare function parseLocalFontImportName(source: string): string | null;
 /** Type for the Vite plugin's `this.error` callback. */
 type EmitError = (msg: string) => never;
-/**
- * Run the timber-fonts transform pass on a single source file.
- *
- * Returns the rewritten code (with font calls inlined and the side-effect
- * `virtual:timber-font-css-register` import prepended) or `null` if the
- * file does not import from any timber-fonts virtual module and therefore
- * needs no transformation.
- */
 export declare function runFontsTransform(code: string, id: string, pipeline: FontPipeline, emitError: EmitError): {
     code: string;
     map: null;

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

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/fonts/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAgClD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAM/E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAE5F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAkB/D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB3E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKtE;AASD,wDAAwD;AACxD,KAAK,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,CAAC;AA8IxC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,SAAS,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GAAG,IAAI,CAkCpC"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/fonts/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AA+BlD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAM/E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAE5F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAkB/D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB3E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKtE;AASD,wDAAwD;AACxD,KAAK,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,CAAC;AAyLxC,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,SAAS,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GAAG,IAAI,CAqDpC"}

package/dist/fonts/virtual-modules.d.ts

@@ -9,9 +9,22 @@
  *   transform hook hasn't run yet, or when an unknown font is referenced
  *   via the default export proxy).
  * - `@timber/fonts/local` — exports `localFont()` as a fallback default.
- * - `virtual:timber-font-css-register` — side-effect module that sets the
- *   combined `@font-face` CSS on `globalThis.__timber_font_css`. The RSC
- *   entry reads this at render time to inline a `<style>` tag.
+ * - `virtual:timber-font-css/<hash>.css` — per-importer CSS module that
+ *   holds the combined `@font-face` + fallback + class CSS for every
+ *   font registered under that importer. The transform hook injects a
+ *   side-effect `import 'virtual:timber-font-css/<hash>.css'` into each
+ *   file that calls a font function, so Vite's CSS pipeline picks it up
+ *   like any other CSS asset. @vitejs/plugin-rsc's `collectCss` walks
+ *   the RSC module graph, finds the virtual module, and injects a
+ *   `<link rel="stylesheet" data-rsc-css-href=...>` via React Float —
+ *   the same machinery component CSS rides on (TIM-828).
+ *
+ *   The `.css` suffix is load-bearing: Vite's `isCSSRequest` regex matches
+ *   on file extension, so keeping it in the virtual id is how we tell
+ *   Vite's CSS pipeline (dev HMR + build asset emission) that this
+ *   module is CSS. The old `virtual:timber-font-css-register` side-effect
+ *   module, `globalThis.__timber_font_css` channel, and inline `<style>`
+ *   tag in the RSC entry were all removed in TIM-828.
  *
  * Design doc: 24-fonts.md
  */
@@ -20,8 +33,39 @@ export declare const VIRTUAL_GOOGLE = "@timber/fonts/google";
 export declare const VIRTUAL_LOCAL = "@timber/fonts/local";
 export declare const RESOLVED_GOOGLE = "\0@timber/fonts/google";
 export declare const RESOLVED_LOCAL = "\0@timber/fonts/local";
-export declare const VIRTUAL_FONT_CSS_REGISTER = "virtual:timber-font-css-register";
-export declare const RESOLVED_FONT_CSS_REGISTER = "\0virtual:timber-font-css-register";
+/**
+ * Prefix used for the per-importer virtual CSS modules. The full id is
+ * `virtual:timber-font-css/<hash>.css` where `<hash>` is a short SHA-256
+ * digest of the importer path. We encode the hash (not the path itself)
+ * so the id stays filesystem-safe and opaque to downstream consumers.
+ */
+export declare const VIRTUAL_FONT_CSS_PREFIX = "virtual:timber-font-css/";
+export declare const VIRTUAL_FONT_CSS_SUFFIX = ".css";
+export declare const RESOLVED_FONT_CSS_PREFIX: string;
+/**
+ * In-memory map from the short hash used in virtual module ids back to
+ * the absolute importer path. Populated by `virtualFontCssIdFor()` when
+ * the transform hook registers an importer and read by the plugin's
+ * `load` hook when Vite asks for the CSS content.
+ *
+ * Scoped to a single `FontPipeline` instance to avoid cross-plugin-
+ * instance collisions during multi-build pipelines.
+ */
+export declare class VirtualFontCssIdMap {
+    private readonly map;
+    /**
+     * Return a stable virtual module id for `importer`. Calling this twice
+     * with the same importer returns the same id. Registering under an
+     * existing hash is idempotent.
+     */
+    idFor(importer: string): string;
+    /** Decode the importer from a resolved (or unresolved) virtual css id. */
+    importerFor(id: string): string | undefined;
+    /** True if `id` is any form of the virtual font css module. */
+    matches(id: string): boolean;
+    /** Drop every registered mapping. Used by tests. */
+    clear(): void;
+}
 /**
  * Generate the virtual module source for `@timber/fonts/google`.
  *

package/dist/fonts/virtual-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-modules.d.ts","sourceRoot":"","sources":["../../src/fonts/virtual-modules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAKpE,eAAO,MAAM,cAAc,yBAAyB,CAAC;AACrD,eAAO,MAAM,aAAa,wBAAwB,CAAC;AACnD,eAAO,MAAM,eAAe,2BAA2B,CAAC;AACxD,eAAO,MAAM,cAAc,0BAA0B,CAAC;AAEtD,eAAO,MAAM,yBAAyB,qCAAqC,CAAC;AAC5E,eAAO,MAAM,0BAA0B,uCAAuC,CAAC;AAU/E;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,MAAM,CAoClF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAanD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,CAAC,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAwB/F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EACpC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,GACrD,MAAM,CAOR"}
+{"version":3,"file":"virtual-modules.d.ts","sourceRoot":"","sources":["../../src/fonts/virtual-modules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAKpE,eAAO,MAAM,cAAc,yBAAyB,CAAC;AACrD,eAAO,MAAM,aAAa,wBAAwB,CAAC;AACnD,eAAO,MAAM,eAAe,2BAA2B,CAAC;AACxD,eAAO,MAAM,cAAc,0BAA0B,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,6BAA6B,CAAC;AAClE,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAC9C,eAAO,MAAM,wBAAwB,QAAiC,CAAC;AAEvE;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA6B;IAEjD;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM/B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAW3C,+DAA+D;IAC/D,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAK5B,oDAAoD;IACpD,KAAK,IAAI,IAAI;CAGd;AAUD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,MAAM,CAoClF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAanD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,CAAC,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAwB/F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EACpC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,GACrD,MAAM,CAOR"}

package/dist/index.js

@@ -1,6 +1,6 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./_chunks/chunk-BYIpzuS7.js";
 import { n as setViteServer } from "./_chunks/dev-warnings-DpGRGoDi.js";
-import { i as scanRoutes, n as generateRouteMap, t as collectInterceptionRewrites } from "./_chunks/interception-DSv3A2Zn.js";
+import { i as scanRoutes, n as generateRouteMap, t as collectInterceptionRewrites } from "./_chunks/interception-BsLCA9gk.js";
 import { t as formatSize } from "./_chunks/format-CYBGxKtc.js";
 import { dirname, extname, join, normalize, resolve } from "node:path";
 import { createRequire } from "node:module";
@@ -1814,15 +1814,37 @@ function shouldActivate(ctx) {
 	return false;
 }
 /**
-* Try to dynamically import a module by name. Returns the default export
-* or the module itself, or undefined if the module is not installed.
+* Try to dynamically import a module by name, resolving from the user's
+* project root rather than from `@timber-js/app`'s own location.
+*
+* Why this matters: pnpm only hoists declared (peer) dependencies into a
+* package's resolution scope. The MDX integration's optional companions
+* — `remark-frontmatter`, `remark-mdx-frontmatter`, `@mdx-js/rollup` — are
+* installed as direct deps of the consumer (e.g. `packages/website`), not
+* `@timber-js/app`. A bare `import('remark-frontmatter')` from inside this
+* file resolves against `packages/timber-app/node_modules` and silently
+* fails with `ERR_MODULE_NOT_FOUND`, which made `tryImport` return
+* `undefined` and skipped frontmatter parsing entirely — leaving MDX to
+* choke on YAML as JS expressions (TIM-840).
+*
+* Resolving relative to `projectRoot` (via `createRequire`) makes the
+* lookup walk the consumer's `node_modules` tree first, which is where
+* pnpm puts the user's deps.
+*
+* Returns the default export, the module itself, or undefined if the
+* module is not installed.
 */
-async function tryImport(name) {
+async function tryImport(name, projectRoot) {
 	try {
-		const mod = await import(name);
+		const mod = await import(pathToFileURL(createRequire(join(projectRoot, "package.json")).resolve(name)).href);
 		return mod.default ?? mod;
 	} catch {
-		return;
+		try {
+			const mod = await import(name);
+			return mod.default ?? mod;
+		} catch {
+			return;
+		}
 	}
 }
 /**
@@ -1837,7 +1859,7 @@ function timberMdx(ctx) {
 	let innerPlugin = null;
 	async function activate() {
 		if (innerPlugin !== null || !shouldActivate(ctx)) return;
-		const createMdxPlugin = await tryImport("@mdx-js/rollup");
+		const createMdxPlugin = await tryImport("@mdx-js/rollup", ctx.root);
 		if (!createMdxPlugin) throw new Error([
 			"[timber] MDX is enabled but @mdx-js/rollup is not installed.",
 			"",
@@ -1848,8 +1870,8 @@ function timberMdx(ctx) {
 		].join("\n"));
 		const mdxConfig = ctx.config.mdx ?? {};
 		const remarkPlugins = [];
-		const remarkFrontmatter = await tryImport("remark-frontmatter");
-		const remarkMdxFrontmatter = await tryImport("remark-mdx-frontmatter");
+		const remarkFrontmatter = await tryImport("remark-frontmatter", ctx.root);
+		const remarkMdxFrontmatter = await tryImport("remark-mdx-frontmatter", ctx.root);
 		if (remarkFrontmatter) remarkPlugins.push(remarkFrontmatter);
 		if (remarkMdxFrontmatter) remarkPlugins.push(remarkMdxFrontmatter);
 		if (mdxConfig.remarkPlugins) remarkPlugins.push(...mdxConfig.remarkPlugins);
@@ -14446,6 +14468,124 @@ function processLocalFont(config, importerPath) {
 		fontFamily: fontStack
 	};
 }
+var RESOLVED_GOOGLE = "\0@timber/fonts/google";
+var RESOLVED_LOCAL = "\0@timber/fonts/local";
+/**
+* Prefix used for the per-importer virtual CSS modules. The full id is
+* `virtual:timber-font-css/<hash>.css` where `<hash>` is a short SHA-256
+* digest of the importer path. We encode the hash (not the path itself)
+* so the id stays filesystem-safe and opaque to downstream consumers.
+*/
+var VIRTUAL_FONT_CSS_PREFIX = "virtual:timber-font-css/";
+var VIRTUAL_FONT_CSS_SUFFIX = ".css";
+"" + VIRTUAL_FONT_CSS_PREFIX;
+/**
+* In-memory map from the short hash used in virtual module ids back to
+* the absolute importer path. Populated by `virtualFontCssIdFor()` when
+* the transform hook registers an importer and read by the plugin's
+* `load` hook when Vite asks for the CSS content.
+*
+* Scoped to a single `FontPipeline` instance to avoid cross-plugin-
+* instance collisions during multi-build pipelines.
+*/
+var VirtualFontCssIdMap = class {
+	map = /* @__PURE__ */ new Map();
+	/**
+	* Return a stable virtual module id for `importer`. Calling this twice
+	* with the same importer returns the same id. Registering under an
+	* existing hash is idempotent.
+	*/
+	idFor(importer) {
+		const hash = createHash("sha256").update(importer).digest("hex").slice(0, 16);
+		this.map.set(hash, importer);
+		return `${VIRTUAL_FONT_CSS_PREFIX}${hash}${VIRTUAL_FONT_CSS_SUFFIX}`;
+	}
+	/** Decode the importer from a resolved (or unresolved) virtual css id. */
+	importerFor(id) {
+		const body = id.startsWith("\0") ? id.slice(1) : id;
+		if (!body.startsWith("virtual:timber-font-css/")) return void 0;
+		if (!body.endsWith(".css")) return void 0;
+		const hash = body.slice(24, body.length - 4);
+		return this.map.get(hash);
+	}
+	/** True if `id` is any form of the virtual font css module. */
+	matches(id) {
+		const body = id.startsWith("\0") ? id.slice(1) : id;
+		return body.startsWith("virtual:timber-font-css/") && body.endsWith(".css");
+	}
+	/** Drop every registered mapping. Used by tests. */
+	clear() {
+		this.map.clear();
+	}
+};
+/**
+* Convert a font family name to a PascalCase export name.
+* e.g. "JetBrains Mono" → "JetBrains_Mono"
+*/
+function familyToExportName(family) {
+	return family.replace(/\s+/g, "_");
+}
+/**
+* Generate the virtual module source for `@timber/fonts/google`.
+*
+* The transform hook replaces real call sites at build time, so this
+* module only matters as a runtime fallback. We export a Proxy default
+* that handles any font name plus named exports for known families
+* (for tree-shaking).
+*/
+function generateGoogleVirtualModule(fonts) {
+	const families = /* @__PURE__ */ new Set();
+	for (const font of fonts) if (font.provider === "google") families.add(font.family);
+	const lines = [
+		"// Auto-generated virtual module: @timber/fonts/google",
+		"// Each export is a font loader function that returns a FontResult.",
+		"",
+		"function createFontResult(family, config) {",
+		"  return {",
+		"    className: `timber-font-${family.toLowerCase().replace(/\\s+/g, \"-\")}`,",
+		"    style: { fontFamily: family },",
+		"    variable: config?.variable,",
+		"  };",
+		"}",
+		"",
+		"export default new Proxy({}, {",
+		"  get(_, prop) {",
+		"    if (typeof prop === \"string\") {",
+		"      return (config) => createFontResult(prop.replace(/_/g, \" \"), config);",
+		"    }",
+		"  }",
+		"});"
+	];
+	for (const family of families) {
+		const exportName = familyToExportName(family);
+		lines.push("");
+		lines.push(`export function ${exportName}(config) {`);
+		lines.push(`  return createFontResult('${family}', config);`);
+		lines.push("}");
+	}
+	return lines.join("\n");
+}
+/**
+* Generate the virtual module source for `@timber/fonts/local`.
+*
+* Like the google virtual module, this is a runtime fallback. The
+* transform hook normally replaces `localFont(...)` calls with static
+* `FontResult` objects at build time.
+*/
+function generateLocalVirtualModule() {
+	return [
+		"// Auto-generated virtual module: @timber/fonts/local",
+		"",
+		"export default function localFont(config) {",
+		"  const family = config?.family || \"Local Font\";",
+		"  return {",
+		"    className: `timber-font-${family.toLowerCase().replace(/\\s+/g, \"-\")}`,",
+		"    style: { fontFamily: family },",
+		"    variable: config?.variable,",
+		"  };",
+		"}"
+	].join("\n");
+}
 //#endregion
 //#region src/fonts/pipeline.ts
 var FontPipeline = class {
@@ -14458,6 +14598,17 @@ var FontPipeline = class {
 	* the map contents are mutable through the methods below.
 	*/
 	_entries = /* @__PURE__ */ new Map();
+	/**
+	* Per-importer virtual CSS module id registry. Populated by the
+	* transform hook when it inlines a font function call, read by the
+	* plugin's `load` hook when Vite asks for the module's CSS source.
+	*
+	* Lives on the pipeline (rather than a module-level singleton) so
+	* multiple parallel plugin instances — e.g. in the test suite — cannot
+	* collide on the hash-to-importer map. Also makes `clear()` reset the
+	* id map alongside the font entries so test fixtures start clean.
+	*/
+	cssIdMap = new VirtualFontCssIdMap();
 	/** Number of registered fonts. */
 	size() {
 		return this._entries.size;
@@ -14546,6 +14697,7 @@ var FontPipeline = class {
 	/** Drop every registered font. Used by tests and rebuild flows. */
 	clear() {
 		this._entries.clear();
+		this.cssIdMap.clear();
 	}
 	/**
 	* Iterate every cached Google Font binary across all registered entries,
@@ -14577,6 +14729,30 @@ var FontPipeline = class {
 		for (const entry of this._entries.values()) cssParts.push(renderEntryCss(entry));
 		return cssParts.join("\n\n");
 	}
+	/**
+	* Render the combined CSS for every font registered from a specific
+	* importer file. This is the anchor point for the per-importer virtual
+	* CSS module (`virtual:timber-font-css/<hash>.css`) that the transform
+	* hook injects as a side-effect import.
+	*
+	* Scoping by importer means two concurrent requests rendering different
+	* routes cannot see each other's font CSS: each importer's virtual
+	* module only contains CSS for fonts that module registered. It also
+	* means Vite's CSS HMR can surgically reload just the affected importer
+	* when a single file changes, rather than rebuilding one giant blob.
+	*
+	* Returns an empty string when no fonts are registered under `importer`.
+	* The empty string is semantically equivalent to "no CSS" — Vite's CSS
+	* pipeline handles it as a valid empty CSS module.
+	*/
+	getCssForSegment(importer) {
+		const cssParts = [];
+		for (const entry of this._entries.values()) {
+			if (entry.importer !== importer) continue;
+			cssParts.push(renderEntryCss(entry));
+		}
+		return cssParts.join("\n\n");
+	}
 };
 /**
 * Render the combined CSS for a single font entry.
@@ -14602,78 +14778,6 @@ function renderEntryCss(entry) {
 	else cssParts.push(generateFontFamilyClass(entry.className, entry.fontFamily));
 	return cssParts.join("\n\n");
 }
-var RESOLVED_GOOGLE = "\0@timber/fonts/google";
-var RESOLVED_LOCAL = "\0@timber/fonts/local";
-var VIRTUAL_FONT_CSS_REGISTER = "virtual:timber-font-css-register";
-var RESOLVED_FONT_CSS_REGISTER = "\0virtual:timber-font-css-register";
-/**
-* Convert a font family name to a PascalCase export name.
-* e.g. "JetBrains Mono" → "JetBrains_Mono"
-*/
-function familyToExportName(family) {
-	return family.replace(/\s+/g, "_");
-}
-/**
-* Generate the virtual module source for `@timber/fonts/google`.
-*
-* The transform hook replaces real call sites at build time, so this
-* module only matters as a runtime fallback. We export a Proxy default
-* that handles any font name plus named exports for known families
-* (for tree-shaking).
-*/
-function generateGoogleVirtualModule(fonts) {
-	const families = /* @__PURE__ */ new Set();
-	for (const font of fonts) if (font.provider === "google") families.add(font.family);
-	const lines = [
-		"// Auto-generated virtual module: @timber/fonts/google",
-		"// Each export is a font loader function that returns a FontResult.",
-		"",
-		"function createFontResult(family, config) {",
-		"  return {",
-		"    className: `timber-font-${family.toLowerCase().replace(/\\s+/g, \"-\")}`,",
-		"    style: { fontFamily: family },",
-		"    variable: config?.variable,",
-		"  };",
-		"}",
-		"",
-		"export default new Proxy({}, {",
-		"  get(_, prop) {",
-		"    if (typeof prop === \"string\") {",
-		"      return (config) => createFontResult(prop.replace(/_/g, \" \"), config);",
-		"    }",
-		"  }",
-		"});"
-	];
-	for (const family of families) {
-		const exportName = familyToExportName(family);
-		lines.push("");
-		lines.push(`export function ${exportName}(config) {`);
-		lines.push(`  return createFontResult('${family}', config);`);
-		lines.push("}");
-	}
-	return lines.join("\n");
-}
-/**
-* Generate the virtual module source for `@timber/fonts/local`.
-*
-* Like the google virtual module, this is a runtime fallback. The
-* transform hook normally replaces `localFont(...)` calls with static
-* `FontResult` objects at build time.
-*/
-function generateLocalVirtualModule() {
-	return [
-		"// Auto-generated virtual module: @timber/fonts/local",
-		"",
-		"export default function localFont(config) {",
-		"  const family = config?.family || \"Local Font\";",
-		"  return {",
-		"    className: `timber-font-${family.toLowerCase().replace(/\\s+/g, \"-\")}`,",
-		"    style: { fontFamily: family },",
-		"    variable: config?.variable,",
-		"  };",
-		"}"
-	].join("\n");
-}
 //#endregion
 //#region src/fonts/transform.ts
 /**
@@ -14842,13 +14946,45 @@ function transformLocalFonts(transformedCode, originalCode, importerId, pipeline
 /**
 * Run the timber-fonts transform pass on a single source file.
 *
-* Returns the rewritten code (with font calls inlined and the side-effect
-* `virtual:timber-font-css-register` import prepended) or `null` if the
-* file does not import from any timber-fonts virtual module and therefore
-* needs no transformation.
+* Returns the rewritten code (with font calls inlined and a side-effect
+* `import 'virtual:timber-font-css/<hash>.css'` prepended so Vite's CSS
+* pipeline owns the font CSS) or `null` if the file does not import from
+* any timber-fonts virtual module and therefore needs no transformation.
 */
+/**
+* File extensions that may contain real font imports. Only JS/TS module
+* variants are scanned. Excluding non-JS extensions (.mdx, .md, .css,
+* .json, etc.) prevents false-positive matches on text that mentions a
+* font specifier inside documentation, code fences, or asset metadata.
+*
+* Why this matters: the heuristic below is a substring check (`code.includes`),
+* not an AST parse. An MDX file documenting Next.js font compatibility
+* (e.g. a code fence containing `import { Inter } from 'next/font/google'`)
+* would trigger the same match as a real import. The transform then prepends
+* `import 'virtual:timber-font-css/<hash>.css';` to the file, which breaks
+* downstream parsers that require the file to start with their own delimiter
+* — most notably MDX frontmatter, which must start at line 1 col 1 for
+* `remark-frontmatter` to recognise it. See TIM-840.
+*/
+var FONT_IMPORT_SCANNABLE_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+]);
+function hasScannableExtension(id) {
+	const path = id.split("?", 1)[0];
+	const dot = path.lastIndexOf(".");
+	if (dot === -1) return false;
+	return FONT_IMPORT_SCANNABLE_EXTENSIONS.has(path.slice(dot).toLowerCase());
+}
 function runFontsTransform(code, id, pipeline, emitError) {
 	if (id.startsWith("\0") || id.includes("node_modules")) return null;
+	if (!hasScannableExtension(id)) return null;
 	const hasGoogleImport = code.includes("@timber/fonts/google") || code.includes("@timber-js/app/fonts/google") || code.includes("next/font/google");
 	const hasLocalImport = code.includes("@timber/fonts/local") || code.includes("@timber-js/app/fonts/local") || code.includes("next/font/local");
 	if (!hasGoogleImport && !hasLocalImport) return null;
@@ -14856,7 +14992,7 @@ function runFontsTransform(code, id, pipeline, emitError) {
 	if (hasGoogleImport) transformedCode = transformGoogleFonts(transformedCode, code, id, pipeline, emitError);
 	if (hasLocalImport) transformedCode = transformLocalFonts(transformedCode, code, id, pipeline, emitError);
 	if (transformedCode !== code) {
-		if (pipeline.size() > 0) transformedCode = `import '${VIRTUAL_FONT_CSS_REGISTER}';\n` + transformedCode;
+		if (pipeline.size() > 0) transformedCode = `import '${pipeline.cssIdMap.idFor(id)}';\n` + transformedCode;
 		return {
 			code: transformedCode,
 			map: null
@@ -15010,6 +15146,7 @@ function timberFonts(ctx) {
 	const pipeline = new FontPipeline();
 	return {
 		name: "timber-fonts",
+		enforce: "pre",
 		resolveId(id) {
 			let cleanId = id.startsWith("\0") ? id.slice(1) : id;
 			if (cleanId.startsWith(ctx.root)) {
@@ -15019,14 +15156,17 @@ function timberFonts(ctx) {
 			}
 			if (cleanId === "@timber/fonts/google") return RESOLVED_GOOGLE;
 			if (cleanId === "@timber/fonts/local") return RESOLVED_LOCAL;
-			if (cleanId === "virtual:timber-font-css-register") return RESOLVED_FONT_CSS_REGISTER;
+			if (pipeline.cssIdMap.matches(cleanId)) return "\0" + cleanId;
 			return null;
 		},
 		async load(id) {
 			if (id === "\0@timber/fonts/google") return generateGoogleVirtualModule(pipeline.fonts());
 			if (id === "\0@timber/fonts/local") return generateLocalVirtualModule();
-			if (id === "\0virtual:timber-font-css-register") {
+			if (pipeline.cssIdMap.matches(id)) {
+				const importer = pipeline.cssIdMap.importerFor(id);
+				if (!importer) return "";
 				if (ctx.dev) for (const font of pipeline.googleFonts()) {
+					if (font.importer !== importer) continue;
 					if (pipeline.hasFaces(font.id)) continue;
 					try {
 						const faces = await resolveDevFontFaces(font);
@@ -15036,7 +15176,7 @@ function timberFonts(ctx) {
 						console.warn(`[timber-fonts] Failed to resolve Google font "${font.family}": ${msg}. Will retry on next request.`);
 					}
 				}
-				return `globalThis.__timber_font_css = ${JSON.stringify(pipeline.getCss())};`;
+				return pipeline.getCssForSegment(importer);
 			}
 			return null;
 		},