astro 6.0.0-beta.0 → 6.0.0-beta.2

package/client.d.ts

@@ -58,9 +58,8 @@ declare module 'astro:assets' {
 		Image: typeof import('./components/Image.astro').default;
 		Picture: typeof import('./components/Picture.astro').default;
 		Font: typeof import('./components/Font.astro').default;
-		getFontData: (
-			cssVariable: import('astro:assets').CssVariable,
-		) => Array<import('astro:assets').FontData>;
+		fontData: Record<import('astro:assets').CssVariable, Array<import('astro:assets').FontData>>;
+		getFontBuffer: (url: string) => Promise<Buffer>;
 	};
 
 	type ImgAttributes = import('./dist/type-utils.js').WithRequired<
@@ -82,7 +81,8 @@ declare module 'astro:assets' {
 		Picture,
 		Font,
 		inferRemoteSize,
-		getFontData,
+		fontData,
+		getFontBuffer,
 	}: AstroAssets;
 }
 

package/components/Font.astro

@@ -1,6 +1,6 @@
 ---
 import * as mod from 'virtual:astro:assets/fonts/internal';
-import { filterPreloads } from 'astro/assets/fonts/runtime';
+import { filterPreloads } from '../dist/assets/fonts/core/filter-preloads.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 
 // TODO: remove check when fonts are stabilized

package/dist/assets/endpoint/node.js

@@ -1,21 +1,23 @@
-import { outDir } from "astro:assets";
+import { outDir, serverDir } from "astro:assets";
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { isParentDirectory } from "@astrojs/internal-helpers/path";
 import { handleImageRequest } from "./shared.js";
 async function loadLocalImage(src, url) {
+  const outDirURL = resolveOutDir();
   const idx = url.pathname.indexOf("/_image");
   if (idx > 0) {
     src = src.slice(idx);
   }
-  if (!URL.canParse("." + src, outDir)) {
+  if (!URL.canParse("." + src, outDirURL)) {
     return void 0;
   }
-  const fileUrl = new URL("." + src, outDir);
+  const fileUrl = new URL("." + src, outDirURL);
   if (fileUrl.protocol !== "file:") {
     return void 0;
   }
-  if (!isParentDirectory(fileURLToPath(outDir), fileURLToPath(fileUrl))) {
+  if (!isParentDirectory(fileURLToPath(outDirURL), fileURLToPath(fileUrl))) {
     return void 0;
   }
   try {
@@ -34,6 +36,21 @@ const GET = async ({ request }) => {
     });
   }
 };
+function resolveOutDir() {
+  const serverDirPath = fileURLToPath(serverDir);
+  const rel = path.relative(serverDirPath, fileURLToPath(outDir));
+  const serverFolder = path.basename(serverDirPath);
+  let serverEntryFolderURL = path.dirname(import.meta.url);
+  while (!serverEntryFolderURL.endsWith(serverFolder)) {
+    serverEntryFolderURL = path.dirname(serverEntryFolderURL);
+  }
+  const serverEntryURL = serverEntryFolderURL + "/entry.mjs";
+  const outDirURL = new URL(appendForwardSlash(rel), serverEntryURL);
+  return outDirURL;
+}
+function appendForwardSlash(pth) {
+  return pth.endsWith("/") ? pth : pth + "/";
+}
 export {
   GET
 };

package/dist/assets/fonts/config.d.ts

@@ -70,11 +70,38 @@ export declare const localFontFamilySchema: z.ZodObject<{
     name: z.ZodString;
     cssVariable: z.ZodString;
 }, z.core.$strict>;
+export declare const fontProviderSchema: z.ZodObject<{
+    name: z.ZodString;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    init: z.ZodOptional<z.ZodCustom<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
+    resolveFont: z.ZodCustom<(options: import("./types.js").ResolveFontOptions<never>) => {
+        fonts: Array<import("unifont").FontFaceData>;
+    } | Promise<{
+        fonts: Array<import("unifont").FontFaceData>;
+    } | undefined> | undefined, (options: import("./types.js").ResolveFontOptions<never>) => {
+        fonts: Array<import("unifont").FontFaceData>;
+    } | Promise<{
+        fonts: Array<import("unifont").FontFaceData>;
+    } | undefined> | undefined>;
+    listFonts: z.ZodOptional<z.ZodCustom<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
+}, z.core.$strict>;
 export declare const remoteFontFamilySchema: z.ZodObject<{
     provider: z.ZodObject<{
-        entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+        name: z.ZodString;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        init: z.ZodOptional<z.ZodCustom<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
+        resolveFont: z.ZodCustom<(options: import("./types.js").ResolveFontOptions<never>) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined, (options: import("./types.js").ResolveFontOptions<never>) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined>;
+        listFonts: z.ZodOptional<z.ZodCustom<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
     }, z.core.$strict>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     weights: z.ZodOptional<z.ZodTuple<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>], z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     styles: z.ZodOptional<z.ZodTuple<[z.ZodEnum<{
         normal: "normal";

package/dist/assets/fonts/config.js

@@ -37,6 +37,13 @@ const localFontFamilySchema = z.object({
   provider: z.literal(LOCAL_PROVIDER_NAME),
   variants: z.tuple([variantSchema], variantSchema)
 }).strict();
+const fontProviderSchema = z.object({
+  name: z.string(),
+  config: z.record(z.string(), z.any()).optional(),
+  init: z.custom((v) => typeof v === "function").optional(),
+  resolveFont: z.custom((v) => typeof v === "function"),
+  listFonts: z.custom((v) => typeof v === "function").optional()
+}).strict();
 const remoteFontFamilySchema = z.object({
   ...requiredFamilyAttributesSchema.shape,
   ...fallbacksSchema.shape,
@@ -44,10 +51,8 @@ const remoteFontFamilySchema = z.object({
     weight: true,
     style: true
   }).shape,
-  provider: z.object({
-    entrypoint: entrypointSchema,
-    config: z.record(z.string(), z.any()).optional()
-  }).strict(),
+  provider: fontProviderSchema,
+  options: z.record(z.string(), z.any()).optional(),
   weights: z.tuple([weightSchema], weightSchema).optional(),
   styles: z.tuple([styleSchema], styleSchema).optional(),
   subsets: z.tuple([z.string()], z.string()).optional(),
@@ -55,6 +60,7 @@ const remoteFontFamilySchema = z.object({
 }).strict();
 export {
   displaySchema,
+  fontProviderSchema,
   localFontFamilySchema,
   remoteFontFamilySchema,
   styleSchema,

package/dist/assets/fonts/constants.d.ts

@@ -1,9 +1,12 @@
 import type { Defaults, FontType } from './types.js';
 export declare const LOCAL_PROVIDER_NAME = "local";
 export declare const DEFAULTS: Defaults;
-/** Used to serialize data, to be used by public APIs */
 export declare const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
+export declare const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime";
+export declare const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID: string;
+export declare const BUFFER_VIRTUAL_MODULE_ID_PREFIX = "virtual:astro:assets/fonts/file/";
+export declare const RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX: string;
 export declare const ASSETS_DIR = "fonts";
 export declare const CACHE_DIR = "./fonts/";
 export declare const FONT_TYPES: readonly ["woff2", "woff", "otf", "ttf", "eot"];

package/dist/assets/fonts/constants.js

@@ -10,6 +10,10 @@ const DEFAULTS = {
 };
 const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime";
+const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID = "\0" + RUNTIME_VIRTUAL_MODULE_ID;
+const BUFFER_VIRTUAL_MODULE_ID_PREFIX = "virtual:astro:assets/fonts/file/";
+const RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX = "\0" + BUFFER_VIRTUAL_MODULE_ID_PREFIX;
 const ASSETS_DIR = "fonts";
 const CACHE_DIR = "./fonts/";
 const FONT_TYPES = ["woff2", "woff", "otf", "ttf", "eot"];
@@ -38,6 +42,7 @@ const GENERIC_FALLBACK_NAMES = [
 const FONTS_TYPES_FILE = "fonts.d.ts";
 export {
   ASSETS_DIR,
+  BUFFER_VIRTUAL_MODULE_ID_PREFIX,
   CACHE_DIR,
   DEFAULTS,
   FONTS_TYPES_FILE,
@@ -45,6 +50,9 @@ export {
   FONT_TYPES,
   GENERIC_FALLBACK_NAMES,
   LOCAL_PROVIDER_NAME,
+  RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX,
+  RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
+  RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/assets/fonts/core/create-get-font-buffer.d.ts

@@ -0,0 +1,4 @@
+import type { BufferImports } from './../types.js';
+export declare function createGetFontBuffer({ bufferImports }: {
+    bufferImports?: BufferImports;
+}): (url: string) => Promise<Buffer<ArrayBufferLike>>;

package/dist/assets/fonts/core/create-get-font-buffer.js

@@ -0,0 +1,35 @@
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+function createGetFontBuffer({ bufferImports }) {
+  return async function getFontBuffer(url) {
+    if (!bufferImports) {
+      throw new AstroError(AstroErrorData.ExperimentalFontsNotEnabled);
+    }
+    const hash = url.split("/").pop() ?? "";
+    const fn = bufferImports[hash];
+    if (!fn) {
+      throw new AstroError({
+        ...AstroErrorData.FontBufferNotFound,
+        message: AstroErrorData.FontBufferNotFound.message(url)
+      });
+    }
+    let mod;
+    try {
+      mod = await fn();
+    } catch {
+      throw new AstroError({
+        ...AstroErrorData.FontBufferNotFound,
+        message: AstroErrorData.FontBufferNotFound.message(url)
+      });
+    }
+    if (!mod?.default) {
+      throw new AstroError({
+        ...AstroErrorData.FontBufferNotFound,
+        message: AstroErrorData.FontBufferNotFound.message(url)
+      });
+    }
+    return mod.default;
+  };
+}
+export {
+  createGetFontBuffer
+};

package/dist/assets/fonts/core/filter-preloads.d.ts

@@ -0,0 +1,2 @@
+import type { PreloadData, PreloadFilter } from '../types.js';
+export declare function filterPreloads(data: Array<PreloadData>, preload: PreloadFilter): Array<PreloadData> | null;

package/dist/assets/fonts/{runtime.js → core/filter-preloads.js}

@@ -1,19 +1,3 @@
-import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-function createGetFontData({ consumableMap }) {
-  return function getFontData(cssVariable) {
-    if (!consumableMap) {
-      throw new AstroError(AstroErrorData.ExperimentalFontsNotEnabled);
-    }
-    const data = consumableMap.get(cssVariable);
-    if (!data) {
-      throw new AstroError({
-        ...AstroErrorData.FontFamilyNotFound,
-        message: AstroErrorData.FontFamilyNotFound.message(cssVariable)
-      });
-    }
-    return data;
-  };
-}
 function filterPreloads(data, preload) {
   if (!preload) {
     return null;
@@ -49,6 +33,5 @@ function checkWeight(input, target) {
   return input === target;
 }
 export {
-  createGetFontData,
   filterPreloads
 };

package/dist/assets/fonts/core/resolve-families.d.ts

@@ -1,17 +1,16 @@
-import type { Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver } from '../definitions.js';
+import type { Hasher, LocalProviderUrlResolver } from '../definitions.js';
 import type { FontFamily, ResolvedFontFamily } from '../types.js';
 /**
  * Dedupes properties if applicable and resolves entrypoints.
  */
-export declare function resolveFamily({ family, hasher, remoteFontProviderResolver, localProviderUrlResolver, }: {
+export declare function resolveFamily({ family, hasher, localProviderUrlResolver, }: {
     family: FontFamily;
     hasher: Hasher;
-    remoteFontProviderResolver: RemoteFontProviderResolver;
     localProviderUrlResolver: LocalProviderUrlResolver;
-}): Promise<ResolvedFontFamily>;
+}): ResolvedFontFamily;
 /**
  * A function for convenience. The actual logic lives in resolveFamily
  */
 export declare function resolveFamilies({ families, ...dependencies }: {
     families: Array<FontFamily>;
-} & Omit<Parameters<typeof resolveFamily>[0], 'family'>): Promise<Array<ResolvedFontFamily>>;
+} & Omit<Parameters<typeof resolveFamily>[0], 'family'>): Array<ResolvedFontFamily>;

package/dist/assets/fonts/core/resolve-families.js

@@ -18,10 +18,9 @@ function resolveVariants({
     })
   }));
 }
-async function resolveFamily({
+function resolveFamily({
   family,
   hasher,
-  remoteFontProviderResolver,
   localProviderUrlResolver
 }) {
   const name = withoutQuotes(family.name);
@@ -44,22 +43,18 @@ async function resolveFamily({
     subsets: family.subsets ? dedupe(family.subsets) : void 0,
     formats: family.formats ? dedupe(family.formats) : void 0,
     fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0,
-    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0,
-    // This will be Astro specific eventually
-    provider: await remoteFontProviderResolver.resolve(family.provider)
+    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0
   };
 }
-async function resolveFamilies({
+function resolveFamilies({
   families,
   ...dependencies
 }) {
-  return await Promise.all(
-    families.map(
-      (family) => resolveFamily({
-        family,
-        ...dependencies
-      })
-    )
+  return families.map(
+    (family) => resolveFamily({
+      family,
+      ...dependencies
+    })
   );
 }
 export {

package/dist/assets/fonts/definitions.d.ts

@@ -1,16 +1,10 @@
 import type * as unifont from 'unifont';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
-import type { AstroFontProviderResolveFontOptions, FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, PreloadData, ResolvedFontProvider, Style } from './types.js';
+import type { FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, PreloadData, ResolveFontOptions, Style } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
     hashObject: (input: Record<string, any>) => string;
 }
-export interface RemoteFontProviderModResolver {
-    resolve: (id: string) => Promise<any>;
-}
-export interface RemoteFontProviderResolver {
-    resolve: (provider: FontProvider) => Promise<ResolvedFontProvider>;
-}
 export interface LocalProviderUrlResolver {
     resolve: (input: string) => string;
 }
@@ -91,10 +85,10 @@ export interface Storage {
     setItemRaw: (key: string, value: any) => Promise<void>;
 }
 export interface FontResolver {
-    resolveFont: (options: AstroFontProviderResolveFontOptions & {
-        provider: string;
+    resolveFont: (options: ResolveFontOptions<Record<string, any>> & {
+        provider: FontProvider;
     }) => Promise<Array<unifont.FontFaceData>>;
     listFonts: (options: {
-        provider: string;
+        provider: FontProvider;
     }) => Promise<string[] | undefined>;
 }

package/dist/assets/fonts/infra/require-local-provider-url-resolver.js

@@ -1,5 +1,5 @@
-import { fileURLToPath } from "node:url";
-import { resolveEntrypoint } from "../utils.js";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
 class RequireLocalProviderUrlResolver {
   #root;
   // TODO: remove when stabilizing
@@ -11,8 +11,16 @@ class RequireLocalProviderUrlResolver {
     this.#root = root;
     this.#intercept = intercept;
   }
+  #resolveEntrypoint(root, entrypoint) {
+    const require2 = createRequire(root);
+    try {
+      return pathToFileURL(require2.resolve(entrypoint));
+    } catch {
+      return new URL(entrypoint, root);
+    }
+  }
   resolve(input) {
-    const path = fileURLToPath(resolveEntrypoint(this.#root, input));
+    const path = fileURLToPath(this.#resolveEntrypoint(this.#root, input));
     this.#intercept?.(path);
     return path;
   }

package/dist/assets/fonts/infra/unifont-font-resolver.d.ts

@@ -1,10 +1,18 @@
 import type { FontFaceData, Provider } from 'unifont';
 import type { FontResolver, Hasher, Storage } from '../definitions.js';
-import type { AstroFontProviderResolveFontOptions, ResolvedFontFamily } from '../types.js';
-type NonEmptyProviders = [Provider, ...Array<Provider>];
+import type { FontProvider, ResolvedFontFamily, ResolveFontOptions } from '../types.js';
+type NonEmptyProviders = [
+    Provider<string, Record<string, any>>,
+    ...Array<Provider<string, Record<string, any>>>
+];
 export declare class UnifontFontResolver implements FontResolver {
     #private;
     private constructor();
+    static idFromProvider({ hasher, provider }: {
+        hasher: Hasher;
+        provider: FontProvider;
+    }): string;
+    static astroToUnifontProvider(astroProvider: FontProvider): Provider;
     static extractUnifontProviders({ families, hasher, }: {
         families: Array<ResolvedFontFamily>;
         hasher: Hasher;
@@ -14,11 +22,11 @@ export declare class UnifontFontResolver implements FontResolver {
         hasher: Hasher;
         storage: Storage;
     }): Promise<UnifontFontResolver>;
-    resolveFont({ familyName, provider, ...rest }: AstroFontProviderResolveFontOptions & {
-        provider: string;
+    resolveFont({ familyName, provider, options, ...rest }: ResolveFontOptions<Record<string, any>> & {
+        provider: FontProvider;
     }): Promise<Array<FontFaceData>>;
     listFonts({ provider }: {
-        provider: string;
+        provider: FontProvider;
     }): Promise<string[] | undefined>;
 }
 export {};

package/dist/assets/fonts/infra/unifont-font-resolver.js

@@ -1,33 +1,52 @@
-import { createUnifont } from "unifont";
+import { createUnifont, defineFontProvider } from "unifont";
 import { LOCAL_PROVIDER_NAME } from "../constants.js";
 class UnifontFontResolver {
   #unifont;
-  constructor({ unifont }) {
+  #hasher;
+  constructor({
+    unifont,
+    hasher
+  }) {
     this.#unifont = unifont;
+    this.#hasher = hasher;
+  }
+  static idFromProvider({ hasher, provider }) {
+    const hash = hasher.hashObject({
+      name: provider.name,
+      ...provider.config
+    });
+    return `${provider.name}-${hash}`;
+  }
+  static astroToUnifontProvider(astroProvider) {
+    return defineFontProvider(astroProvider.name, async (_options, ctx) => {
+      await astroProvider?.init?.(ctx);
+      return {
+        async resolveFont(familyName, { options, ...rest }) {
+          return await astroProvider.resolveFont({ familyName, options, ...rest });
+        },
+        async listFonts() {
+          return astroProvider.listFonts?.();
+        }
+      };
+    })(astroProvider.config);
   }
   static extractUnifontProviders({
     families,
     hasher
   }) {
-    const hashes = /* @__PURE__ */ new Set();
-    const providers = [];
+    const providers = /* @__PURE__ */ new Map();
     for (const { provider } of families) {
       if (provider === LOCAL_PROVIDER_NAME) {
         continue;
       }
-      const unifontProvider = provider.provider(provider.config);
-      const hash = hasher.hashObject({
-        name: unifontProvider._name,
-        ...provider.config
-      });
-      unifontProvider._name += `-${hash}`;
-      provider.name = unifontProvider._name;
-      if (!hashes.has(hash)) {
-        hashes.add(hash);
-        providers.push(unifontProvider);
+      const id = this.idFromProvider({ hasher, provider });
+      if (!providers.has(id)) {
+        const unifontProvider = this.astroToUnifontProvider(provider);
+        unifontProvider._name = this.idFromProvider({ hasher, provider });
+        providers.set(id, unifontProvider);
       }
     }
-    return providers;
+    return Array.from(providers.values());
   }
   static async create({
     families,
@@ -39,19 +58,42 @@ class UnifontFontResolver {
         storage,
         // TODO: consider enabling, would require new astro errors
         throwOnError: false
-      })
+      }),
+      hasher
     });
   }
   async resolveFont({
     familyName,
     provider,
+    options,
     ...rest
   }) {
-    const { fonts } = await this.#unifont.resolveFont(familyName, rest, [provider]);
+    const { fonts } = await this.#unifont.resolveFont(
+      familyName,
+      {
+        // Options are currently namespaced by provider name, it may change in
+        // https://github.com/unjs/unifont/pull/287
+        options: {
+          [provider.name]: options
+        },
+        ...rest
+      },
+      [
+        UnifontFontResolver.idFromProvider({
+          hasher: this.#hasher,
+          provider
+        })
+      ]
+    );
     return fonts;
   }
   async listFonts({ provider }) {
-    return await this.#unifont.listFonts([provider]);
+    return await this.#unifont.listFonts([
+      UnifontFontResolver.idFromProvider({
+        hasher: this.#hasher,
+        provider
+      })
+    ]);
   }
 }
 export {

package/dist/assets/fonts/orchestrate.d.ts

@@ -1,12 +1,11 @@
 import type { Logger } from '../../core/logger/core.js';
-import type { CssRenderer, FontFileReader, FontMetricsResolver, FontResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
-import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap, InternalConsumableMap, ResolvedFontFamily } from './types.js';
+import type { CssRenderer, FontFileReader, FontMetricsResolver, FontResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
+import type { CreateUrlProxyParams, Defaults, FontDataRecord, FontFamily, FontFileDataMap, InternalConsumableMap, ResolvedFontFamily } from './types.js';
 /**
  * Manages how fonts are resolved:
  *
  * - families are resolved
- * - unifont providers are extracted from families
- * - unifont is initialized
+ * - font resolver is initialized
  *
  * For each family:
  * - We create a URL proxy
@@ -19,10 +18,9 @@ import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFil
  *
  * Once that's done, the collected data is returned
  */
-export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, bold, stringMatcher, createFontResolver, }: {
+export declare function orchestrate({ families, hasher, localProviderUrlResolver, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, bold, stringMatcher, createFontResolver, }: {
     families: Array<FontFamily>;
     hasher: Hasher;
-    remoteFontProviderResolver: RemoteFontProviderResolver;
     localProviderUrlResolver: LocalProviderUrlResolver;
     cssRenderer: CssRenderer;
     systemFallbacksProvider: SystemFallbacksProvider;
@@ -40,5 +38,5 @@ export declare function orchestrate({ families, hasher, remoteFontProviderResolv
 }): Promise<{
     fontFileDataMap: FontFileDataMap;
     internalConsumableMap: InternalConsumableMap;
-    consumableMap: ConsumableMap;
+    fontData: FontDataRecord;
 }>;