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

package/src/fonts/local.ts

@@ -17,6 +17,7 @@ import { resolve, dirname, extname } from 'node:path';
 import type { LocalFontConfig, LocalFontSrc, FontFaceDescriptor, ExtractedFont } from './types.js';
 import { buildFontStack } from './fallbacks.js';
 import { extractLocalFontConfigAst } from './ast.js';
+import { fontOutputBasename, fontUrlPrefix } from './paths.js';
 
 /**
  * Infer the font format from a file extension.
@@ -85,7 +86,7 @@ export function resolveLocalFontPaths(
 export function generateFamilyName(sources: LocalFontSrc[]): string {
   if (sources.length === 0) return 'Local Font';
   const firstPath = sources[0].path;
-  const basename = firstPath.split('/').pop() ?? firstPath;
+  const basename = fontOutputBasename(firstPath);
   // Remove extension and weight/style suffixes for a cleaner family name
   const stem = basename.replace(/\.[^.]+$/, '');
   // Strip common weight/style suffixes to get the family root
@@ -100,19 +101,19 @@ export function generateFamilyName(sources: LocalFontSrc[]): string {
  * Generate @font-face descriptors for local font sources.
  *
  * Each source entry produces one @font-face rule. The `src` descriptor
- * uses a `url()` pointing to the served path under `/_timber/fonts/`.
- * The `urlPrefix` defaults to `/_timber/fonts` — the path used by both
- * the dev server middleware and the production build output.
+ * uses a `url()` pointing to the served path under `<base>_timber/fonts/`.
+ * The `urlPrefix` defaults to `fontUrlPrefix()` (root base) — pass
+ * `fontUrlPrefix(viteBase)` so non-root deployments resolve correctly.
  */
 export function generateLocalFontFaces(
   family: string,
   sources: LocalFontSrc[],
   display: string,
-  urlPrefix = '/_timber/fonts'
+  urlPrefix = fontUrlPrefix()
 ): FontFaceDescriptor[] {
   return sources.map((entry) => {
     const format = inferFontFormat(entry.path);
-    const filename = entry.hashedBasename ?? entry.path.split('/').pop() ?? entry.path;
+    const filename = entry.hashedBasename ?? fontOutputBasename(entry.path);
     return {
       family,
       src: `url('${urlPrefix}/${filename}') format('${format}')`,

package/src/fonts/paths.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared path/URL helpers for the timber-fonts pipeline.
+ *
+ * Two concerns live here:
+ *
+ * - `fontUrlPrefix` — the public URL prefix for font binaries, derived
+ *   from Vite's resolved `base`. Every URL the pipeline emits (@font-face
+ *   src, manifest hrefs, dev middleware matching) must go through this so
+ *   apps deployed under a non-root base (`base: '/my-app/'`) resolve
+ *   fonts correctly. Emitted *file* locations are not base-prefixed —
+ *   only URLs are.
+ *
+ * - `fontOutputBasename` / `hashedFontBasename` — basename derivation for
+ *   local font sources. Paths are absolutized with `resolve()`, which
+ *   produces backslash separators on Windows, so `split('/').pop()` is
+ *   not safe. `path.win32.basename` handles both separators.
+ *
+ * Design doc: 24-fonts.md
+ */
+
+import { win32 } from 'node:path';
+
+/** Directory (relative to the build output / URL root) holding font binaries. */
+export const FONT_OUTPUT_DIR = '_timber/fonts';
+
+/**
+ * Build the URL prefix for font binaries from Vite's resolved `base`.
+ *
+ * `fontUrlPrefix('/')` → `/_timber/fonts`
+ * `fontUrlPrefix('/my-app/')` → `/my-app/_timber/fonts`
+ */
+export function fontUrlPrefix(base = '/'): string {
+  const normalized = base.endsWith('/') ? base : `${base}/`;
+  return `${normalized}${FONT_OUTPUT_DIR}`;
+}
+
+/**
+ * Derive the output basename for a local font source path.
+ *
+ * Uses `path.win32.basename` because it splits on both `/` and `\`,
+ * handling absolute paths produced by `resolve()` on any platform.
+ */
+export function fontOutputBasename(srcPath: string): string {
+  return win32.basename(srcPath);
+}
+
+/**
+ * Derive the content-hashed output basename for a local font source.
+ *
+ * `hashedFontBasename('C:\\fonts\\MyFont-Bold.woff2', 'a1b2c3d4')`
+ * → `MyFont-Bold-a1b2c3d4.woff2`
+ */
+export function hashedFontBasename(srcPath: string, hash: string): string {
+  const basename = fontOutputBasename(srcPath);
+  const ext = win32.extname(basename);
+  const stem = ext ? basename.slice(0, -ext.length) : basename;
+  return `${stem}-${hash}${ext}`;
+}

package/src/fonts/pipeline.ts

@@ -27,27 +27,16 @@
  */
 
 import { readFileSync, existsSync } from 'node:fs';
-import { resolve, normalize, extname } from 'node:path';
+import { resolve, normalize } from 'node:path';
 import type { ExtractedFont, FontEntry, FontFaceDescriptor } from './types.js';
 import type { CachedFont } from './google.js';
 import { contentHash } from './google.js';
 import { generateVariableClass, generateFontFamilyClass, generateFontFaces } from './css.js';
 import { generateFallbackCss } from './fallbacks.js';
 import { generateLocalFontFaces } from './local.js';
+import { hashedFontBasename, fontUrlPrefix } from './paths.js';
 import { VirtualFontCssIdMap } from './virtual-modules.js';
 
-/**
- * Backwards-compatible alias for the registry shape that the standalone
- * `pruneRegistryEntries` and `generateAllFontCss` helpers operate on.
- *
- * The `FontPipeline` itself stores `Map<string, FontEntry>` internally and
- * never exposes its underlying map. Tests and external callers that build
- * their own font registries (e.g. fixtures in `tests/fonts-hmr-prune.test.ts`)
- * still pass plain `Map<string, ExtractedFont>` instances to the standalone
- * helpers, which is why the alias survives.
- */
-export type FontRegistry = Map<string, ExtractedFont>;
-
 export class FontPipeline {
   /**
    * The single per-font store. Keyed by `FontEntry.id` (which is itself
@@ -62,10 +51,21 @@ export class FontPipeline {
   /** When true, local font sources are content-hashed at registration time. */
   private readonly _hashOnRegister: boolean;
 
+  /**
+   * Vite's resolved `base`. Set from the plugin's `configResolved` hook so
+   * every @font-face URL the pipeline renders carries the prefix.
+   */
+  private _base = '/';
+
   constructor(opts?: { hashOnRegister?: boolean }) {
     this._hashOnRegister = opts?.hashOnRegister ?? false;
   }
 
+  /** Set Vite's resolved `base` (from `configResolved`). */
+  setBase(base: string): void {
+    this._base = base;
+  }
+
   /**
    * Per-importer virtual CSS module id registry. Populated by the
    * transform hook when it inlines a font function call, read by the
@@ -156,11 +156,7 @@ export class FontPipeline {
         const absolutePath = normalize(resolve(src.path));
         if (!existsSync(absolutePath)) continue;
         const data = readFileSync(absolutePath);
-        const hash = contentHash(data);
-        const basename = src.path.split('/').pop() ?? src.path;
-        const ext = extname(basename);
-        const stem = ext ? basename.slice(0, -ext.length) : basename;
-        src.hashedBasename = `${stem}-${hash}${ext}`;
+        src.hashedBasename = hashedFontBasename(src.path, contentHash(data));
       }
     }
     this._entries.set(entry.id, entry);
@@ -247,9 +243,10 @@ export class FontPipeline {
    * or lazily in `load` for dev).
    */
   getCss(): string {
+    const urlPrefix = fontUrlPrefix(this._base);
     const cssParts: string[] = [];
     for (const entry of this._entries.values()) {
-      cssParts.push(renderEntryCss(entry));
+      cssParts.push(renderEntryCss(entry, urlPrefix));
     }
     return cssParts.join('\n\n');
   }
@@ -271,10 +268,11 @@ export class FontPipeline {
    * pipeline handles it as a valid empty CSS module.
    */
   getCssForSegment(importer: string): string {
+    const urlPrefix = fontUrlPrefix(this._base);
     const cssParts: string[] = [];
     for (const entry of this._entries.values()) {
       if (entry.importer !== importer) continue;
-      cssParts.push(renderEntryCss(entry));
+      cssParts.push(renderEntryCss(entry, urlPrefix));
     }
     return cssParts.join('\n\n');
   }
@@ -283,16 +281,19 @@ export class FontPipeline {
 /**
  * Render the combined CSS for a single font entry.
  *
- * Mirrors the standalone `generateFontCss` helper exported from
- * `virtual-modules.ts`, but reads `faces` straight off the entry instead
- * of from a parallel map. Kept private to this module so the only public
- * way to render a `FontEntry`'s CSS is through `FontPipeline.getCss()`.
+ * Reads `faces` straight off the entry. Private to this module — the only
+ * public way to render a `FontEntry`'s CSS is through `FontPipeline.getCss()`.
  */
-function renderEntryCss(entry: FontEntry): string {
+function renderEntryCss(entry: FontEntry, urlPrefix: string): string {
   const cssParts: string[] = [];
 
   if (entry.provider === 'local' && entry.localSources) {
-    const faces = generateLocalFontFaces(entry.family, entry.localSources, entry.display);
+    const faces = generateLocalFontFaces(
+      entry.family,
+      entry.localSources,
+      entry.display,
+      urlPrefix
+    );
     const faceCss = generateFontFaces(faces);
     if (faceCss) cssParts.push(faceCss);
   }
@@ -313,25 +314,3 @@ function renderEntryCss(entry: FontEntry): string {
 
   return cssParts.join('\n\n');
 }
-
-/**
- * Drop every registry entry that originated from `importer` and shares
- * `family`. Standalone helper retained as a public export for the test
- * suite (`tests/fonts-hmr-prune.test.ts`) and any external callers that
- * still build their own `FontRegistry` maps.
- *
- * Prefer `FontPipeline#pruneFor` inside the plugin itself — it also drops
- * attached `faces` and `cachedFiles` in the same operation.
- */
-export function pruneRegistryEntries(
-  registry: FontRegistry,
-  importer: string,
-  family: string
-): void {
-  const familyKey = family.toLowerCase();
-  for (const [id, font] of registry) {
-    if (font.importer === importer && font.family.toLowerCase() === familyKey) {
-      registry.delete(id);
-    }
-  }
-}

package/src/fonts/transform.ts

@@ -221,6 +221,33 @@ export function runFontsTransform(
     );
   }
 
+  // Bail on namespace imports of font modules — the transform cannot
+  // rewrite `fonts.Inter(...)` member calls, so the font would silently
+  // never load.
+  if (analysis.namespaceImports.length > 0) {
+    const first = analysis.namespaceImports[0];
+    emitError(
+      `Namespace imports of font modules are not supported ` +
+        `(\`* as ${first.name}\` at line ${first.line}, column ${first.column}). ` +
+        `Use a named import instead: \`import { Inter } from 'next/font/google'\`.`
+    );
+  }
+
+  // Bail on font binding references the transform cannot rewrite
+  // (`export default Inter({...})`, object-literal nesting, member access
+  // on the call result, aliasing, re-exports). The import declaration is
+  // removed, so leaving these would be a silent runtime ReferenceError.
+  if (analysis.unsupportedUsages.length > 0) {
+    const first = analysis.unsupportedUsages[0];
+    emitError(
+      `Unsupported usage of font function \`${first.name}\` at ` +
+        `line ${first.line}, column ${first.column}. ` +
+        `A font call must be \`const x = Font({...})\` at module scope ` +
+        `(export const is fine). The call result cannot be nested in other ` +
+        `expressions, and the imported font function cannot be aliased or re-exported.`
+    );
+  }
+
   if (analysis.callSites.length === 0 && analysis.bindings.length === 0) return null;
 
   const s = new MagicString(code);

package/src/fonts/virtual-modules.ts

@@ -30,10 +30,7 @@
  */
 
 import { createHash } from 'node:crypto';
-import type { ExtractedFont, FontFaceDescriptor } from './types.js';
-import { generateVariableClass, generateFontFamilyClass, generateFontFaces } from './css.js';
-import { generateFallbackCss } from './fallbacks.js';
-import { generateLocalFontFaces } from './local.js';
+import type { ExtractedFont } from './types.js';
 
 export const VIRTUAL_GOOGLE = '@timber/fonts/google';
 export const VIRTUAL_LOCAL = '@timber/fonts/local';
@@ -180,56 +177,3 @@ export function generateLocalVirtualModule(): string {
     '}',
   ].join('\n');
 }
-
-/**
- * Generate combined CSS for a single extracted font.
- *
- * Includes `@font-face` rules (local or Google), the size-adjusted fallback
- * `@font-face`, and the scoped class rule. For Google fonts the resolved
- * `FontFaceDescriptor[]` must be passed in (from `generateProductionFontFaces`
- * in production or `resolveDevFontFaces` in dev).
- */
-export function generateFontCss(font: ExtractedFont, googleFaces?: FontFaceDescriptor[]): string {
-  const cssParts: string[] = [];
-
-  if (font.provider === 'local' && font.localSources) {
-    const faces = generateLocalFontFaces(font.family, font.localSources, font.display);
-    const faceCss = generateFontFaces(faces);
-    if (faceCss) cssParts.push(faceCss);
-  }
-
-  if (font.provider === 'google' && googleFaces && googleFaces.length > 0) {
-    const faceCss = generateFontFaces(googleFaces);
-    if (faceCss) cssParts.push(faceCss);
-  }
-
-  const fallbackCss = generateFallbackCss(font.family);
-  if (fallbackCss) cssParts.push(fallbackCss);
-
-  if (font.variable) {
-    cssParts.push(generateVariableClass(font.className, font.variable, font.fontFamily));
-  } else {
-    cssParts.push(generateFontFamilyClass(font.className, font.fontFamily));
-  }
-
-  return cssParts.join('\n\n');
-}
-
-/**
- * Generate the CSS output for all extracted fonts.
- *
- * Includes `@font-face` rules for local and Google fonts, fallback rules,
- * and scoped classes. `googleFontFacesMap` provides pre-resolved
- * `FontFaceDescriptor[]` for each Google font (keyed by `ExtractedFont.id`).
- */
-export function generateAllFontCss(
-  registry: Map<string, ExtractedFont>,
-  googleFontFacesMap?: Map<string, FontFaceDescriptor[]>
-): string {
-  const cssParts: string[] = [];
-  for (const font of registry.values()) {
-    const googleFaces = googleFontFacesMap?.get(font.id);
-    cssParts.push(generateFontCss(font, googleFaces));
-  }
-  return cssParts.join('\n\n');
-}

package/src/index.ts

@@ -11,7 +11,7 @@
  */
 
 import type { Plugin, PluginOption } from 'vite';
-import { join, resolve } from 'node:path';
+import { join, relative, resolve } from 'node:path';
 import { createRequire } from 'node:module';
 import react, { reactCompilerPreset } from '@vitejs/plugin-react';
 import { timberContent } from './plugins/content';
@@ -46,7 +46,6 @@ import {
   resolveAppDir,
   resolveClientJavascript,
   resolveBuildDir,
-  DEFAULT_BUILD_DIR,
 } from './plugin-context.js';
 
 // ── Public API ────────────────────────────────────────────────────────────
@@ -251,7 +250,7 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
       ctx.timer.start('config-load');
       const fileConfig = loadTimberConfigFile(viteRoot);
       if (fileConfig) {
-        mergeFileConfig(ctx, fileConfig);
+        ctx.config = mergeFileConfig(ctx.config, fileConfig);
         ctx.clientJavascript = resolveClientJavascript(ctx.config);
       }
       // Apply defaults AFTER merge so file-based config isn't overridden
@@ -353,14 +352,9 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
         resolvedDevPortExplicit = start.explicit;
       }
 
-      // Return the resolved buildDir as Vite's build.outDir so the RSC
-      // plugin and all environment builds write to the correct location.
-      // This is always set — either from timber config, Vite config, or default.
-      const buildOutDir = timberBuildDir
-        ? timberBuildDir
-        : viteOutDir && viteOutDir !== 'dist'
-          ? viteOutDir
-          : DEFAULT_BUILD_DIR;
+      // Derive relative buildOutDir from the absolute ctx.buildDir (set above)
+      // so Vite's config receives a root-relative path.
+      const buildOutDir = relative(resolvedRoot, ctx.buildDir);
 
       // Set per-environment build.outDir so Vite's RSC plugin writes
       // each environment to the correct subdirectory under our buildDir.

package/src/params/resolve-schema.ts

@@ -10,39 +10,7 @@
  */
 
 import type { Codec } from '../codec.js';
-import { isCodec, isStandardSchema, validateSync } from '../schema-bridge.js';
-import type { StandardSchemaV1 } from '../schema-bridge.js';
-
-/**
- * Wrap a Standard Schema into a Codec for route params.
- * Parse throws on failure (invalid param → 404). Serialize returns string.
- */
-function fromParamSchema<T>(fieldName: string, schema: StandardSchemaV1<T>): Codec<T> {
-  return {
-    parse(value: string | string[] | undefined): T {
-      const result = validateSync(schema, value);
-      if (!result.issues) {
-        return result.value;
-      }
-      const messages = result.issues.map((i) => i.message).join(', ');
-      throw new Error(`[timber] Param '${fieldName}' coercion failed: ${messages}`);
-    },
-    serialize(value: T): string | null {
-      if (value === null || value === undefined) return null;
-      if (Array.isArray(value)) return value.join('/');
-      return String(value);
-    },
-  };
-}
-
-/**
- * Resolve a schema entry to a Codec. Accepts Codec<T> or StandardSchemaV1<T>.
- */
-function resolveCodec(fieldName: string, value: unknown): Codec<unknown> {
-  if (isCodec(value)) return value;
-  if (isStandardSchema(value)) return fromParamSchema(fieldName, value);
-  throw new Error(`[timber] Schema field '${fieldName}' is not a valid codec or Standard Schema.`);
-}
+import { isCodec, resolveCodecOrSchema } from '../schema-bridge.js';
 
 /**
  * Reconstruct the bracket key for a segment from its type and param name.
@@ -109,7 +77,7 @@ export function resolveSchemaCodecs(
           `(e.g. codec.optionalCatchAll(codec.string)). Got a non-optional catch-all codec.`
       );
     }
-    resolved[bracketName] = resolveCodec(bracketName, value);
+    resolved[bracketName] = resolveCodecOrSchema(bracketName, value, 'param');
   }
 
   return resolved;

package/src/plugin-context.ts

@@ -9,7 +9,7 @@
  */
 
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { createRequire } from 'node:module';
 import type { RouteTree } from './routing/types';
 import type { BuildManifest } from './server/build-manifest';
@@ -168,22 +168,73 @@ export function resolveBuildDir(
   viteBuildOutDir?: string
 ): string {
   if (timberBuildDir) {
-    return join(root, timberBuildDir);
+    return resolve(root, timberBuildDir);
   }
   if (viteBuildOutDir && viteBuildOutDir !== 'dist') {
-    return join(root, viteBuildOutDir);
+    return resolve(root, viteBuildOutDir);
   }
   return join(root, DEFAULT_BUILD_DIR);
 }
 
 // ── Config file loading ───────────────────────────────────────────────────
 
+/**
+ * Map known timber.config load failures to actionable hints (TIM-1040).
+ * Returns null when the error has no known remedy beyond its own message.
+ *
+ * Known failure modes of loading timber.config.ts via native require():
+ * - Node < 22.18 has no default type stripping → ERR_UNKNOWN_FILE_EXTENSION
+ * - Non-erasable TS syntax (enums, namespaces, parameter properties)
+ *   → ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX / ERR_INVALID_TYPESCRIPT_SYNTAX
+ * - ESM syntax in a `"type": "commonjs"` package → the stripped .ts is
+ *   parsed as CJS and throws SyntaxError: "Unexpected token 'export'"
+ *   (export statements) or "Cannot use import statement outside a
+ *   module" (import statements)
+ */
+export function configLoadHint(configName: string, err: unknown): string | null {
+  const code = (err as NodeJS.ErrnoException | null)?.code;
+  const isTs = configName.endsWith('.ts');
+
+  if (isTs && code === 'ERR_UNKNOWN_FILE_EXTENSION') {
+    return (
+      'Loading a TypeScript config requires Node.js 22.18+ (built-in type stripping). ' +
+      'Upgrade Node.js or rewrite the config as timber.config.js.'
+    );
+  }
+  if (code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' || code === 'ERR_INVALID_TYPESCRIPT_SYNTAX') {
+    return (
+      'Node.js loads the config with type stripping, which only supports erasable TypeScript syntax — ' +
+      'replace enums, namespaces, and constructor parameter properties with plain objects and types.'
+    );
+  }
+  if (
+    isTs &&
+    err instanceof SyntaxError &&
+    /Unexpected token '(export|import)'|Cannot use import statement outside a module/.test(
+      err.message
+    )
+  ) {
+    return (
+      'The config uses ESM syntax but Node.js parsed it as CommonJS — ' +
+      'set "type": "module" in package.json, or use module.exports instead of export default.'
+    );
+  }
+  return null;
+}
+
 /**
  * Load timber.config.ts (or .js, .mjs) from the project root.
  * Returns the config object or null if no config file is found.
+ * Throws a descriptive error naming the file when a config file exists
+ * but fails to load — a broken config must fail loudly, never silently
+ * degrade (see TIM-1066). Known failure modes get an actionable hint
+ * appended (see configLoadHint, TIM-1040).
  *
- * Uses require() which works for ESM modules on Node 22.12+.
- * This keeps timber() synchronous — no async config loading needed.
+ * Uses require() — Node 22.12+ can require() ESM modules, and Node
+ * 22.18+ strips types from .ts files by default (hence the engines
+ * field requiring >=22.18.0). This keeps timber() synchronous — no
+ * async config loading needed.
+ * This is the single config loader — dev, build, and preview all use it.
  */
 export function loadTimberConfigFile(root: string): TimberUserConfig | null {
   const configNames = ['timber.config.ts', 'timber.config.js', 'timber.config.mjs'];
@@ -192,8 +243,17 @@ export function loadTimberConfigFile(root: string): TimberUserConfig | null {
   for (const name of configNames) {
     const configPath = join(root, name);
     if (existsSync(configPath)) {
-      const mod = req(configPath);
-      return (mod.default ?? mod) as TimberUserConfig;
+      try {
+        const mod = req(configPath);
+        return (mod.default ?? mod) as TimberUserConfig;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const hint = configLoadHint(name, err);
+        throw new Error(
+          `[timber] Failed to load ${configPath}: ${message}${hint ? `\n${hint}` : ''}`,
+          { cause: err }
+        );
+      }
     }
   }
   return null;
@@ -228,20 +288,38 @@ export function warnConfigConflicts(
 }
 
 /**
- * Merge file-based config into ctx.config. Inline config (already in ctx.config)
- * takes precedence — file config only fills in missing fields.
+ * Drop own keys whose value is `undefined` so they don't clobber file
+ * config during spread merging. `timber({ buildDir: process.env.BUILD_DIR })`
+ * with the var unset must not erase the timber.config.ts value.
+ */
+function stripUndefined<T extends object>(obj: T): T {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined)) as T;
+}
+
+/**
+ * Merge file-based config (timber.config.ts) with inline config (vite.config.ts).
+ * Inline config takes precedence — file config only fills in missing fields.
+ * Inline keys explicitly set to `undefined` are treated as absent, matching
+ * the `!== undefined` check in warnConfigConflicts.
  */
-export function mergeFileConfig(ctx: PluginContext, fileConfig: TimberUserConfig): void {
-  const inline = ctx.config;
+export function mergeFileConfig(
+  inline: TimberUserConfig,
+  fileConfig: TimberUserConfig
+): TimberUserConfig {
   warnConfigConflicts(inline, fileConfig);
+  const definedInline = stripUndefined(inline);
 
-  ctx.config = {
+  return {
     ...fileConfig,
-    ...inline,
-    ...(fileConfig.limits && inline.limits
-      ? { limits: { ...fileConfig.limits, ...inline.limits } }
+    ...definedInline,
+    ...(fileConfig.limits && definedInline.limits
+      ? { limits: { ...fileConfig.limits, ...stripUndefined(definedInline.limits) } }
+      : {}),
+    ...(fileConfig.dev && definedInline.dev
+      ? { dev: { ...fileConfig.dev, ...stripUndefined(definedInline.dev) } }
+      : {}),
+    ...(fileConfig.mdx && definedInline.mdx
+      ? { mdx: { ...fileConfig.mdx, ...stripUndefined(definedInline.mdx) } }
       : {}),
-    ...(fileConfig.dev && inline.dev ? { dev: { ...fileConfig.dev, ...inline.dev } } : {}),
-    ...(fileConfig.mdx && inline.mdx ? { mdx: { ...fileConfig.mdx, ...inline.mdx } } : {}),
   };
 }