@storybook-astro/framework 1.3.0 → 1.4.0-canary.2

package/dist/{types-BCpJLSTo.d.ts → types--SvYP5Ri.d.ts}

@@ -14,6 +14,54 @@ type StoryRulesOptions = string | {
     configFile: string;
 };
 
+interface StorybookFontProvider {
+    name: string;
+    init?: (context: {
+        storage: FontStorage;
+        root: URL;
+    }) => Promise<void> | void;
+    resolveFont: (options: {
+        familyName: string;
+        weights: string[];
+        styles: string[];
+        subsets: string[];
+        formats: string[];
+    }) => Promise<{
+        fonts: FontFaceData[];
+    } | undefined> | {
+        fonts: FontFaceData[];
+    } | undefined;
+}
+interface FontFaceData {
+    src: Array<{
+        url?: string;
+        name?: string;
+        format?: string;
+        tech?: string;
+    }>;
+    weight?: string | number | [number, number];
+    style?: string;
+    display?: string;
+    unicodeRange?: string[];
+    featureSettings?: string;
+    variationSettings?: string;
+}
+interface StorybookFontFamily {
+    name: string;
+    cssVariable: string;
+    provider: StorybookFontProvider;
+    weights?: Array<string | number>;
+    styles?: string[];
+    subsets?: string[];
+    formats?: string[];
+    fallbacks?: string[];
+    display?: string;
+}
+interface FontStorage {
+    getItem: <T = unknown>(key: string, init?: () => Promise<T> | T) => Promise<T | null>;
+    setItem: (key: string, value: unknown) => Promise<void> | void;
+}
+
 type FrameworkName = CompatibleString<'@storybook-astro/framework'>;
 
 type RenderMode = 'server' | 'static';
@@ -31,6 +79,13 @@ type BaseFrameworkOptions = {
     integrations?: Integration[];
     sanitization?: SanitizationOptions;
     resolveFrom?: string;
+    /**
+     * Astro font families to resolve and inject as @font-face CSS during story
+     * rendering. Pass the same array you have in your `astro.config.ts` under
+     * `fonts:`. Currently honored in development; static/server builds fall
+     * back to no-op stubs.
+     */
+    fonts?: StorybookFontFamily[];
 };
 type ServerFrameworkOptions = BaseFrameworkOptions & {
     renderMode?: 'server';

package/dist/{viteStorybookAstroMiddlewarePlugin-UB6ZLJ4B.js → viteStorybookAstroMiddlewarePlugin-246I5D3Y.js}

@@ -1,7 +1,7 @@
 import {
   createViteServer,
   vitePluginStorybookAstroMiddleware
-} from "./chunk-AYYMNFI6.js";
+} from "./chunk-VZXGPM6P.js";
 import "./chunk-PUTCAN6X.js";
 import "./chunk-B5HHF6FC.js";
 import "./chunk-G3PMV62Z.js";
@@ -9,4 +9,4 @@ export {
   createViteServer,
   vitePluginStorybookAstroMiddleware
 };
-//# sourceMappingURL=viteStorybookAstroMiddlewarePlugin-UB6ZLJ4B.js.map
+//# sourceMappingURL=viteStorybookAstroMiddlewarePlugin-246I5D3Y.js.map

package/dist/vitest/global-setup.js

@@ -1,9 +1,9 @@
 import {
   TESTING_RENDERER_DAEMON_URL_ENV,
   startTestingRendererDaemon
-} from "../chunk-2EABPTOY.js";
+} from "../chunk-BV6V2Z4X.js";
 import "../chunk-WUTCMEF5.js";
-import "../chunk-AYYMNFI6.js";
+import "../chunk-VZXGPM6P.js";
 import "../chunk-PUTCAN6X.js";
 import "../chunk-7YBE4TTI.js";
 import "../chunk-B5HHF6FC.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook-astro/framework",
-  "version": "1.3.0",
+  "version": "1.4.0-canary.2",
   "description": "Community-supported Storybook framework for Astro 5 & 6 components",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -142,9 +142,10 @@
     }
   },
   "dependencies": {
-    "@storybook-astro/renderer": "1.3.0",
+    "@storybook-astro/renderer": "1.4.0-canary.2",
     "hono": "^4.11.12",
     "sanitize-html": "^2.17.0",
+    "tsconfck": "^3.1.6",
     "vite": "^6.4.1 || ^7.0.0 || ^8.0.0"
   }
 }

package/src/lib/resolve-aliased-island.test.ts

@@ -0,0 +1,150 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { resolveAliasedIsland } from './resolve-aliased-island.ts';
+
+describe('resolveAliasedIsland', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'storybook-astro-alias-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  async function writeTsconfig(content: object) {
+    await writeFile(join(tmpDir, 'tsconfig.json'), JSON.stringify(content, null, 2));
+  }
+
+  test('resolves a basic @/ alias to an absolute path', async () => {
+    await mkdir(join(tmpDir, 'src', 'components'), { recursive: true });
+    const counterFile = join(tmpDir, 'src', 'components', 'Counter.tsx');
+
+    await writeFile(counterFile, `export default function Counter() {}`);
+    await writeTsconfig({
+      compilerOptions: {
+        paths: { '@/*': ['src/*'] }
+      }
+    });
+
+    const result = await resolveAliasedIsland('@/components/Counter', tmpDir);
+
+    expect(result).toBe(counterFile.replace(/\\/g, '/'));
+  });
+
+  test('resolves when baseUrl shifts the path root', async () => {
+    await mkdir(join(tmpDir, 'src', 'components'), { recursive: true });
+    const counterFile = join(tmpDir, 'src', 'components', 'Counter.tsx');
+
+    await writeFile(counterFile, `export default function Counter() {}`);
+    // With baseUrl: "src", paths are relative to src/
+    await writeTsconfig({
+      compilerOptions: {
+        baseUrl: 'src',
+        paths: { '@/*': ['*'] }
+      }
+    });
+
+    const result = await resolveAliasedIsland('@/components/Counter', tmpDir);
+
+    expect(result).toBe(counterFile.replace(/\\/g, '/'));
+  });
+
+  test('falls back to second target when first does not exist on disk', async () => {
+    await mkdir(join(tmpDir, 'app', 'components'), { recursive: true });
+    const counterFile = join(tmpDir, 'app', 'components', 'Counter.tsx');
+
+    await writeFile(counterFile, `export default function Counter() {}`);
+    // First target points at a non-existent dir; second target resolves.
+    await writeTsconfig({
+      compilerOptions: {
+        paths: { '@/*': ['missing/*', 'app/*'] }
+      }
+    });
+
+    const result = await resolveAliasedIsland('@/components/Counter', tmpDir);
+
+    expect(result).toBe(counterFile.replace(/\\/g, '/'));
+  });
+
+  test('resolves an alias with an explicit file extension in the specifier', async () => {
+    await mkdir(join(tmpDir, 'src'), { recursive: true });
+    const file = join(tmpDir, 'src', 'Button.tsx');
+
+    await writeFile(file, `export default function Button() {}`);
+    await writeTsconfig({ compilerOptions: { paths: { '@/*': ['src/*'] } } });
+
+    const result = await resolveAliasedIsland('@/Button.tsx', tmpDir);
+
+    expect(result).toBe(file.replace(/\\/g, '/'));
+  });
+
+  test('returns undefined when aliased file does not exist on disk', async () => {
+    await writeTsconfig({ compilerOptions: { paths: { '@/*': ['src/*'] } } });
+
+    const result = await resolveAliasedIsland('@/components/Missing', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined when tsconfig has no paths', async () => {
+    await mkdir(join(tmpDir, 'src'), { recursive: true });
+    await writeFile(join(tmpDir, 'src', 'Counter.tsx'), `export default function Counter() {}`);
+    await writeTsconfig({ compilerOptions: {} });
+
+    const result = await resolveAliasedIsland('@/Counter', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined when tsconfig.json is absent', async () => {
+    const result = await resolveAliasedIsland('@/Counter', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined for relative specifiers (already handled elsewhere)', async () => {
+    const result = await resolveAliasedIsland('./components/Counter', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined for absolute paths', async () => {
+    const result = await resolveAliasedIsland('/abs/path/Counter.tsx', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined for virtual: specifiers', async () => {
+    const result = await resolveAliasedIsland('virtual:astro-container-renderers', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined for astro: specifiers', async () => {
+    const result = await resolveAliasedIsland('astro:scripts/page.js', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('returns undefined for /@fs/ specifiers', async () => {
+    const result = await resolveAliasedIsland('/@fs/abs/path/Counter.tsx', tmpDir);
+
+    expect(result).toBeUndefined();
+  });
+
+  test('resolves a custom alias prefix (not @/)', async () => {
+    await mkdir(join(tmpDir, 'src'), { recursive: true });
+    const file = join(tmpDir, 'src', 'Widget.vue');
+
+    await writeFile(file, `<template><div /></template>`);
+    await writeTsconfig({ compilerOptions: { paths: { '~/*': ['src/*'] } } });
+
+    const result = await resolveAliasedIsland('~/Widget', tmpDir);
+
+    expect(result).toBe(file.replace(/\\/g, '/'));
+  });
+});

package/src/lib/resolve-aliased-island.ts

@@ -0,0 +1,97 @@
+import { access } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parse } from 'tsconfck';
+
+// Islands embedded in `.astro` components are frequently imported through a
+// tsconfig path alias (e.g. `@/components/Counter`). The raw aliased specifier
+// is baked into `<astro-island component-url>` and `import()`d verbatim, so it
+// must be turned into an on-disk path before it can hydrate. This helper is
+// used as a last resort after the existing resolution has already had its
+// chance.
+
+const ALIAS_EXTS = ['.tsx', '.ts', '.jsx', '.js', '.vue', '.svelte', '.mts', '.mjs'];
+
+async function isFile(candidate: string): Promise<boolean> {
+  try {
+    await access(candidate);
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolves a tsconfig-aliased island specifier (e.g. `@/components/Counter`)
+ * to an absolute on-disk file path, or `undefined` when it is not a tsconfig
+ * alias or no matching file exists. Already-resolvable specifiers are skipped
+ * so this runs only as a genuine last resort.
+ */
+export async function resolveAliasedIsland(
+  specifier: string,
+  resolveFrom: string
+): Promise<string | undefined> {
+  // Skip specifiers the existing resolution can already handle.
+  if (
+    !specifier ||
+    specifier.startsWith('./') ||
+    specifier.startsWith('../') ||
+    specifier.startsWith('/') ||
+    specifier.startsWith('\0') ||
+    specifier.startsWith('virtual:') ||
+    specifier.startsWith('astro:') ||
+    specifier.startsWith('@astrojs/') ||
+    specifier.startsWith('@id/') ||
+    specifier.startsWith('/@fs/')
+  ) {
+    return undefined;
+  }
+
+  let result;
+
+  try {
+    result = await parse(resolve(resolveFrom, 'tsconfig.json'));
+  } catch {
+    return undefined;
+  }
+
+  const compilerOptions = result.tsconfig?.compilerOptions ?? {};
+  const paths: Record<string, string[]> = compilerOptions.paths ?? {};
+
+  if (Object.keys(paths).length === 0) {
+    return undefined;
+  }
+
+  // tsconfig paths resolve relative to baseUrl when present, otherwise the
+  // tsconfig directory (which tsconfck gives us as the tsconfig file's dir).
+  const tsconfigDir = result.tsconfigFile
+    ? resolve(result.tsconfigFile, '..')
+    : resolveFrom;
+  const root = compilerOptions.baseUrl
+    ? resolve(tsconfigDir, compilerOptions.baseUrl)
+    : tsconfigDir;
+
+  for (const [pattern, targets] of Object.entries(paths)) {
+    const prefix = pattern.replace(/\*$/, '');
+
+    if (!specifier.startsWith(prefix)) {
+      continue;
+    }
+
+    const rest = specifier.slice(prefix.length);
+
+    for (const target of targets) {
+      const resolvedTarget = target.replace(/\*$/, '');
+      const base = resolve(root, resolvedTarget, rest);
+      const candidates = [base, ...ALIAS_EXTS.map((ext) => `${base}${ext}`)];
+
+      for (const candidate of candidates) {
+        if (await isFile(candidate)) {
+          return candidate.replace(/\\/g, '/');
+        }
+      }
+    }
+  }
+
+  return undefined;
+}

package/src/loadUserAstroConfig.ts

@@ -0,0 +1,59 @@
+import { loadConfigFromFile } from 'vite';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { AstroIntegration } from 'astro';
+
+const CONFIG_FILENAMES = [
+  'astro.config.ts',
+  'astro.config.mjs',
+  'astro.config.js',
+  'astro.config.cjs',
+];
+
+/**
+ * Loads integrations declared in the user's astro.config.* so that any Vite
+ * plugins they register (e.g. astro-icon's virtual:astro-icon resolver) are
+ * present in both the main Storybook Vite server and the internal Astro SSR
+ * server.  Returns an empty array on any failure so the calling code can
+ * continue with only the framework-level integrations.
+ */
+export async function loadUserAstroIntegrations(resolveFrom: string): Promise<AstroIntegration[]> {
+  const configFile = CONFIG_FILENAMES.find(name => existsSync(resolve(resolveFrom, name)));
+
+  if (!configFile) {
+    return [];
+  }
+
+  try {
+    const result = await loadConfigFromFile(
+      { command: 'serve', mode: 'development' },
+      configFile,
+      resolveFrom
+    );
+
+    if (!result?.config) {
+      return [];
+    }
+
+    const config = result.config as { integrations?: unknown };
+    const raw = config.integrations;
+
+    if (!raw) {
+      return [];
+    }
+
+    // Astro allows nested arrays from conditional spreads (e.g. ...whenX(() => mdx()))
+    const flat = (Array.isArray(raw) ? raw : [raw]).flat(Infinity);
+
+    return flat.filter(
+      (i): i is AstroIntegration => Boolean(i) && typeof i === 'object' && 'name' in i && 'hooks' in i
+    );
+  } catch (err) {
+    console.warn(
+      '[storybook-astro] Could not load astro.config to discover integrations:',
+      err instanceof Error ? err.message : String(err)
+    );
+
+    return [];
+  }
+}

package/src/middleware.ts

@@ -6,6 +6,7 @@ import { ensureAstroPassthroughImageService } from './astroImageService.ts';
 import { createAstroRenderHandler, type HandlerProps } from './astroRenderHandler.ts';
 import type { Integration } from './integrations/index.ts';
 import type { SanitizationOptions } from './lib/sanitization.ts';
+import { resolveAliasedIsland } from './lib/resolve-aliased-island.ts';
 import { resolveStoryModuleMock } from './module-mocks.ts';
 import { addRenderers, resolveClientModules } from 'virtual:astro-container-renderers';
 
@@ -18,6 +19,7 @@ type HandlerFactoryOptions = {
   loadModule?: (id: string) => Promise<{ default: unknown }>;
   invalidateModuleGraph?: () => void;
   resolveModule?: (specifier: string) => string | undefined;
+  resolveFrom?: string;
 };
 
 export type { HandlerProps };
@@ -52,6 +54,19 @@ export async function handlerFactory(
         return resolution;
       }
 
+      // Last resort: an island imported via a tsconfig path alias (e.g. `@/...`)
+      // has its raw aliased specifier baked into the island's component-url.
+      // Resolve it to an on-disk file and hand back a `/@fs/` URL the dev Vite
+      // server can serve so the island still hydrates.
+      const aliasedIsland = await resolveAliasedIsland(
+        specifier,
+        options?.resolveFrom ?? process.cwd()
+      );
+
+      if (aliasedIsland) {
+        return `/@fs/${aliasedIsland}`;
+      }
+
       return specifier;
     }
   });

package/src/productionRenderRuntime.ts

@@ -2,6 +2,7 @@ import { resolve } from 'node:path';
 import { createAstroRenderHandler, type HandlerProps } from './astroRenderHandler.ts';
 import type { Integration } from './integrations/index.ts';
 import type { SanitizationOptions } from './lib/sanitization.ts';
+import type { FrameworkOptions } from './types.ts';
 import {
   createClientModuleResolver,
   createProductionAstroContainer,
@@ -34,6 +35,7 @@ type ProductionRenderRuntimeOptions = {
   trackedSpecifiers: Set<string>;
   resolveFrom: string;
   resolveComponentId?: (id: string) => string;
+  fonts?: FrameworkOptions['fonts'];
 };
 
 /** Creates the shared SSR runtime used by both build-time prerendering and the standalone render server. */
@@ -43,7 +45,8 @@ export async function createProductionRenderRuntime(
   const viteServer = await createStorySsrViteServer({
     integrations: options.integrations,
     trackedSpecifiers: options.trackedSpecifiers,
-    resolveFrom: options.resolveFrom
+    resolveFrom: options.resolveFrom,
+    fonts: options.fonts
   });
 
   try {
@@ -58,7 +61,8 @@ export async function createProductionRenderRuntime(
     const astroContainer = await createProductionAstroContainer({
       integrations: options.integrations,
       resolveClientModule,
-      viteServer
+      viteServer,
+      resolveFrom: options.resolveFrom
     });
 
     const loadModule = async (moduleId: string) => {

package/src/storySsrVite.ts

@@ -4,9 +4,11 @@ import type { experimental_AstroContainer as AstroContainer } from 'astro/contai
 import { ensureAstroPassthroughImageService } from './astroImageService.ts';
 import { importAstroConfig } from './importAstroConfig.ts';
 import type { Integration } from './integrations/index.ts';
+import { resolveAliasedIsland } from './lib/resolve-aliased-island.ts';
 import { ssrLoadModuleWithFsFallback } from './lib/ssr-load-module-with-fs-fallback.ts';
 import { resolveStoryModuleMock } from './module-mocks.ts';
-import { vitePluginAstroFontsFallback } from './vitePluginAstroFontsFallback.ts';
+import type { FrameworkOptions } from './types.ts';
+import { vitePluginAstroFonts } from './vitePluginAstroFonts.ts';
 import { vitePluginAstroIntegrationOptsFallback } from './vitePluginAstroIntegrationOptsFallback.ts';
 import { vitePluginAstroRoutesFallback } from './vitePluginAstroRoutesFallback.ts';
 import { vitePluginAstroVueFallback } from './vitePluginAstroVueFallback.ts';
@@ -16,6 +18,7 @@ export async function createStorySsrViteServer(options: {
   integrations: Integration[];
   trackedSpecifiers: Set<string>;
   resolveFrom: string;
+  fonts?: FrameworkOptions['fonts'];
 }) {
   const { getViteConfig, passthroughImageService } = await importAstroConfig(options.resolveFrom);
   const astroConfig = await getViteConfig(
@@ -44,7 +47,7 @@ export async function createStorySsrViteServer(options: {
     },
     plugins: [
       createProjectAstroResolutionPlugin(options.resolveFrom),
-      vitePluginAstroFontsFallback(),
+      vitePluginAstroFonts({ fonts: options.fonts, root: options.resolveFrom }),
       vitePluginAstroIntegrationOptsFallback(),
       vitePluginAstroVueFallback(),
       vitePluginAstroRoutesFallback(),
@@ -107,6 +110,7 @@ export async function createProductionAstroContainer(options: {
   integrations: Integration[];
   resolveClientModule: (specifier: string) => string | undefined;
   viteServer: ViteDevServer;
+  resolveFrom: string;
 }) {
   ensureAstroPassthroughImageService();
 
@@ -136,6 +140,15 @@ export async function createProductionAstroContainer(options: {
         return resolution;
       }
 
+      // Last resort: an island imported via a tsconfig path alias (e.g. `@/...`)
+      // never matches the static map under its raw specifier. Resolve the alias
+      // to an on-disk path and look that up in the built module map instead.
+      const abs = await resolveAliasedIsland(specifier, options.resolveFrom);
+
+      if (abs) {
+        return options.resolveClientModule(abs) ?? specifier;
+      }
+
       return specifier;
     }
   });

package/src/types.ts

@@ -3,10 +3,11 @@ import type { InlineConfig } from 'vite';
 import type { Integration } from './integrations/index.ts';
 import type { SanitizationOptions } from './lib/sanitization.ts';
 import type { StoryRulesOptions } from './rules-options.ts';
+import type { StorybookFontFamily } from './vitePluginAstroFonts.ts';
 
 type FrameworkName = CompatibleString<'@storybook-astro/framework'>;
 
-export type { Integration, SanitizationOptions, StoryRulesOptions };
+export type { Integration, SanitizationOptions, StoryRulesOptions, StorybookFontFamily };
 export type RenderMode = 'server' | 'static';
 
 export type ServerBuildOptions = {
@@ -25,6 +26,13 @@ type BaseFrameworkOptions = {
   integrations?: Integration[];
   sanitization?: SanitizationOptions;
   resolveFrom?: string;
+  /**
+   * Astro font families to resolve and inject as @font-face CSS during story
+   * rendering. Pass the same array you have in your `astro.config.ts` under
+   * `fonts:`. Currently honored in development; static/server builds fall
+   * back to no-op stubs.
+   */
+  fonts?: StorybookFontFamily[];
 };
 
 type ServerFrameworkOptions = BaseFrameworkOptions & {

package/src/vitePluginAstro.ts

@@ -1,6 +1,7 @@
 import { mergeConfig, type InlineConfig } from 'vite';
 import type { Integration } from './integrations/index.ts';
 import { importAstroConfig } from './importAstroConfig.ts';
+import { loadUserAstroIntegrations } from './loadUserAstroConfig.ts';
 
 const ASTRO_PLUGINS_THAT_ARE_SUPPOSEDLY_NOT_NEEDED_IN_STORYBOOK = [
   '@astro/plugin-actions',
@@ -38,13 +39,19 @@ export async function mergeWithAstroConfig(
   const { getViteConfig } = await importAstroConfig(resolveFrom);
   const safeIntegrations = integrations ?? [];
 
+  const frameworkIntegrations = await Promise.all(
+    safeIntegrations.map((integration) => integration.loadIntegration(resolveFrom))
+  );
+
+  const userIntegrations = await loadUserAstroIntegrations(resolveFrom);
+  const frameworkNames = new Set(frameworkIntegrations.map(i => i.name));
+  const extraIntegrations = userIntegrations.filter(i => !frameworkNames.has(i.name));
+
   const astroConfig = await getViteConfig(
     {},
     {
       configFile: false,
-      integrations: await Promise.all(
-        safeIntegrations.map((integration) => integration.loadIntegration(resolveFrom))
-      )
+      integrations: [...frameworkIntegrations, ...extraIntegrations]
     }
   )({
     mode,

package/src/vitePluginAstroBuildPrerender.ts

@@ -138,6 +138,7 @@ export function vitePluginAstroBuildPrerender(options: FrameworkOptions): Plugin
         staticCssMap,
         trackedSpecifiers,
         resolveFrom,
+        fonts: options.fonts,
         bundle
       });
 
@@ -162,6 +163,7 @@ async function prerenderAstroStories(options: {
   staticCssMap: StaticCssMap;
   trackedSpecifiers: Set<string>;
   resolveFrom: string;
+  fonts?: FrameworkOptions['fonts'];
   bundle: Rollup.OutputBundle;
 }) {
   const runtime = await createProductionRenderRuntime({
@@ -170,7 +172,8 @@ async function prerenderAstroStories(options: {
     storyRulesConfigFilePath: options.storyRulesConfigFilePath,
     staticModuleMap: options.staticModuleMap,
     trackedSpecifiers: options.trackedSpecifiers,
-    resolveFrom: options.resolveFrom
+    resolveFrom: options.resolveFrom,
+    fonts: options.fonts
   });
   const assetPathMap = buildAssetPathMap(options.bundle);