fontdue-js 3.0.0-alpha8 → 3.0.0

package/dist/components/FontdueProvider/index.server.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { FontdueProvider_props } from './index.js';
+import '../../next/registerSingleTenantResolver.js';
 export type { FontdueProvider_props } from './index.js';
 export type { FontdueProviderPreloadedQuery } from '../../loadFontdueProviderQuery.js';
 export type { FontdueServerConfig } from '../../relay/serverConfig.js';

package/dist/components/FontdueProvider/index.server.js

@@ -3,6 +3,16 @@ import React from 'react';
 import FontdueProvider from './index.js';
 import loadFontdueProviderQueryImpl from '../../loadFontdueProviderQuery.js';
 import { setFontdueServerConfig } from '../../relay/serverConfig.js';
+// Side-effect import: registers the single-tenant ambient config resolver so a
+// single-tenant foundry that mounts <FontdueProvider> never has to call a
+// per-render setup function. The module statically pulls in only browser-safe
+// code and lazy-loads the Next request APIs (next/headers, next/navigation)
+// behind a dynamic import that runs only when the resolver resolves config —
+// keeping next/* off this react-server entrypoint's eager graph. The resolver
+// no-ops in multi-tenant mode (which drives config through the slot) and is
+// inert in the default build Astro/RR7 use. See
+// ../../next/registerSingleTenantResolver.ts.
+import '../../next/registerSingleTenantResolver.js';
 // Stub for the RSC export condition. The default `<FontdueProvider>` server
 // entrypoint (this file) awaits the query for consumers, so RSC users should
 // never call it manually. Re-exporting a throwing stub makes the mistake

package/dist/components/NewsletterSignup/index.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { SerializablePreloadedQuery, type LoadQueryOptions } from '../../relay/loadSerializableQuery.js';
 import { NewsletterSignupQuery } from '../../__generated__/NewsletterSignupQuery.graphql.js';
 import { Config } from '../ConfigContext.js';
 export type NewsletterSignupPreloadedQuery = SerializablePreloadedQuery<NewsletterSignupQuery>;
-export declare function loadNewsletterSignupQuery(): Promise<NewsletterSignupPreloadedQuery>;
+export declare function loadNewsletterSignupQuery(options?: LoadQueryOptions): Promise<NewsletterSignupPreloadedQuery>;
 export interface NewsletterSignup_props {
     optInLabel?: string;
     successLabel?: string;

package/dist/components/NewsletterSignup/index.js

@@ -13,8 +13,8 @@ import useSerializablePreloadedQuery from '../../relay/useSerializablePreloadedQ
 import NewsletterSignupQueryNode from '../../__generated__/NewsletterSignupQuery.graphql.js';
 import { EnsureFontdueContext } from '../FontdueContextProvider/index.js';
 const updateCustomerMutation = (_NewsletterSignupUpdateCustomerMutation.hash && _NewsletterSignupUpdateCustomerMutation.hash !== "769087891b6f263122bbb630b3f2ca6c" && console.error("The definition of 'NewsletterSignupUpdateCustomerMutation' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _NewsletterSignupUpdateCustomerMutation);
-export async function loadNewsletterSignupQuery() {
-  return loadSerializableQuery(NewsletterSignupQueryNode, {});
+export async function loadNewsletterSignupQuery(options) {
+  return loadSerializableQuery(NewsletterSignupQueryNode, {}, options);
 }
 const query = (_NewsletterSignupQuery.hash && _NewsletterSignupQuery.hash !== "24b303198a6038318723fc0124548862" && console.error("The definition of 'NewsletterSignupQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _NewsletterSignupQuery);
 function NewsletterSignupComponent(_ref) {

package/dist/components/Root/index.js

@@ -71,11 +71,25 @@ const getInitialElements = () => {
   return map;
 };
 const Root = props => {
+  var _props$config;
+  // The script-tag integration is client-only — there is no server render to
+  // forward a preview token to — so the admin toolbar must enter/exit preview
+  // by toggling the marker cookie in the browser. Force it on here, where the
+  // integration is unambiguously client-side. (The admin's Fontdue session
+  // rides the credentialed cross-origin GraphQL fetch and gates the reveal.)
+  const config = {
+    ...props.config,
+    preview: {
+      ...((_props$config = props.config) === null || _props$config === void 0 ? void 0 : _props$config.preview),
+      clientSide: true
+    }
+  };
+
   // use a Map here instead of an array in case we register the same element
   // more than once (otherwise we run into issues rendering the component
   // twice into the same element). this also gives us a way to set unique keys.
   const [elements, setElements] = useState(getInitialElements());
-  const store = useRef(createDefaultStore(props.config));
+  const store = useRef(createDefaultStore(config));
   useEffect(() => {
     // watch for any new or removed fontdue elements
 
@@ -190,7 +204,7 @@ const Root = props => {
   return /*#__PURE__*/React.createElement(FontdueProvider, {
     url: props.url,
     stripeIntegration: props.stripeIntegration,
-    config: props.config,
+    config: config,
     components: props.components,
     store: store.current
   }, /*#__PURE__*/React.createElement(React.Fragment, null, Array.from(elements).map(_ref => {

package/dist/components/TestFontsForm/index.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { TestFontsForm_Query } from '../../__generated__/TestFontsForm_Query.graphql.js';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { SerializablePreloadedQuery, type LoadQueryOptions } from '../../relay/loadSerializableQuery.js';
 import { Config } from '../ConfigContext.js';
 export interface TestFontsForm_props {
     agreementLabel?: string;
@@ -8,7 +8,7 @@ export interface TestFontsForm_props {
     newsletterCheckboxChecked?: boolean;
 }
 export type TestFontsFormPreloadedQuery = SerializablePreloadedQuery<TestFontsForm_Query>;
-export declare function loadTestFontsFormQuery(): Promise<TestFontsFormPreloadedQuery>;
+export declare function loadTestFontsFormQuery(options?: LoadQueryOptions): Promise<TestFontsFormPreloadedQuery>;
 export declare function TestFontsFormPreloadedQueryRenderer({ preloadedQuery, ...rest }: TestFontsForm_props & {
     preloadedQuery: TestFontsFormPreloadedQuery;
 }): React.JSX.Element;

package/dist/components/TestFontsForm/index.js

@@ -194,8 +194,8 @@ const TestFontsFormComponent = _ref2 => {
   }));
 };
 const query = (_TestFontsForm_Query.hash && _TestFontsForm_Query.hash !== "cd43f0cacc4dcf01cf94fb1ff97197ca" && console.error("The definition of 'TestFontsForm_Query' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _TestFontsForm_Query);
-export async function loadTestFontsFormQuery() {
-  return loadSerializableQuery(TestFontsFormQueryNode, {});
+export async function loadTestFontsFormQuery(options) {
+  return loadSerializableQuery(TestFontsFormQueryNode, {}, options);
 }
 export function TestFontsFormPreloadedQueryRenderer(_ref4) {
   let {

package/dist/components/TypeTester/TypeTesterStandalone.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Alignment, Direction, FeaturesProp } from './types.js';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { SerializablePreloadedQuery, type LoadQueryOptions } from '../../relay/loadSerializableQuery.js';
 import { TypeTesterStandaloneQuery } from '../../__generated__/TypeTesterStandaloneQuery.graphql.js';
 import { Config } from '../ConfigContext.js';
 interface TypeTesterStandaloneComponent_props {
@@ -30,7 +30,7 @@ export interface LoadTypeTesterQueryVariables {
     familyName: string;
     styleName: string;
 }
-export declare function loadTypeTesterQuery(variables: LoadTypeTesterQueryVariables): Promise<TypeTesterPreloadedQuery>;
+export declare function loadTypeTesterQuery(variables: LoadTypeTesterQueryVariables, options?: LoadQueryOptions): Promise<TypeTesterPreloadedQuery>;
 export declare function TypeTesterStandalonePreloadedQueryRenderer({ preloadedQuery, ...rest }: TypeTesterStandaloneComponent_props & {
     preloadedQuery: TypeTesterPreloadedQuery;
 }): React.JSX.Element;

package/dist/components/TypeTester/TypeTesterStandalone.js

@@ -100,11 +100,11 @@ function TypeTesterStandaloneComponent(_ref) {
   }));
 }
 const query = (_TypeTesterStandaloneQuery.hash && _TypeTesterStandaloneQuery.hash !== "951214eacb2370ea3ca0b19bebe7fbe7" && console.error("The definition of 'TypeTesterStandaloneQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _TypeTesterStandaloneQuery);
-export async function loadTypeTesterQuery(variables) {
+export async function loadTypeTesterQuery(variables, options) {
   return loadSerializableQuery(TypeTesterStandaloneQueryNode, {
     familyName: variables.familyName,
     styleName: variables.styleName
-  });
+  }, options);
 }
 export function TypeTesterStandalonePreloadedQueryRenderer(_ref3) {
   let {

package/dist/components/TypeTester/index.js

@@ -142,12 +142,14 @@ const TypeTester = _ref => {
   }, _ref3 => {
     let {
       loaded,
-      style
+      style,
+      verticalMetrics
     } = _ref3;
     if (loaded) {
       return /*#__PURE__*/React.createElement(TypeTesterContent, _extends({}, props, {
         ref: contentRef,
         fontStyles: style,
+        verticalMetrics: verticalMetrics,
         truncate: config.truncate,
         direction: props.direction,
         min: config.size.min,

package/dist/components/TypeTester/useTypeTesterStyler.d.ts

@@ -1,6 +1,7 @@
 import { EditorState } from 'draft-js';
 import { Alignment } from './types.js';
 import { VariableSettings } from '../../utils.js';
+import { VerticalMetrics } from '../useFontStyle.js';
 export type ColumnsConfig = false | {
     count: 'auto' | number;
     width: string;
@@ -21,13 +22,14 @@ export interface UseTypeTesterStylerProps {
     focused: boolean;
     truncate: boolean | number;
     fontStyles: React.CSSProperties;
+    verticalMetrics?: VerticalMetrics | null;
     content: EditorState;
     contentEdited: boolean;
     alignment: Alignment;
     variableSettings: VariableSettings | null;
     columns: ColumnsConfig;
 }
-declare const useTypeTesterStyler: ({ size, autofit, autofitOnChange, features, setSize, min, max, truncate, focused, lineHeight, letterSpacing, fontStyles, content, contentEdited, alignment, variableSettings, columns, }: UseTypeTesterStylerProps) => {
+declare const useTypeTesterStyler: ({ size, autofit, autofitOnChange, features, setSize, min, max, truncate, focused, lineHeight, letterSpacing, fontStyles, verticalMetrics, content, contentEdited, alignment, variableSettings, columns, }: UseTypeTesterStylerProps) => {
     ref: import("react").RefObject<HTMLDivElement | null>;
     style: import("react").CSSProperties;
 };

package/dist/components/TypeTester/useTypeTesterStyler.js

@@ -15,6 +15,7 @@ const useTypeTesterStyler = _ref => {
     lineHeight,
     letterSpacing,
     fontStyles,
+    verticalMetrics,
     content,
     contentEdited,
     alignment,
@@ -58,33 +59,82 @@ const useTypeTesterStyler = _ref => {
   const truncateLines = truncate === true ? 1 : typeof truncate === 'number' ? Math.max(0, Math.floor(truncate)) : 0;
   const shouldTruncate = truncateLines > 0 && !focused;
 
-  // The trailing ellipsis needs `-webkit-line-clamp`, which can't coexist with
-  // CSS multi-column. `columns` is set by default, so the ellipsis is only
-  // available in single-column mode; otherwise the text is hard-clipped.
-  const ellipsis = shouldTruncate && !columns;
+  // How far a line's ink spills past its line-box, top and bottom, as a fraction
+  // of the font-size (em). `fontLoader` feeds these exact metrics into the
+  // @font-face as ascent/descent-override, so this matches the browser's line
+  // geometry precisely. It is 0 once the line-height is at least the font's
+  // natural content height ((ascender − descender) / unitsPerEm) — i.e. for any
+  // normal reading line-height — and only grows for tight, overlapping setting.
+  // Kept in em (not px) so it scales with the *rendered* size, including the
+  // `--type-tester--adjustment` that shrinks the preview on mobile.
+  const lineOverflowEm = shouldTruncate && verticalMetrics && verticalMetrics.unitsPerEm > 0 ? Math.max(0, ((verticalMetrics.ascender - verticalMetrics.descender) / verticalMetrics.unitsPerEm - lineHeight) / 2) : 0;
+
+  // Columns are what make truncation overflow flow sideways — into clipped,
+  // off-screen columns — instead of stacking below the last visible line. That
+  // is what lets the metric padding reveal descenders/ascenders cleanly, and it
+  // means a multi-column tester (e.g. a 3-column specimen) truncates to
+  // `truncateLines` lines *per column*. When truncating with columns disabled we
+  // still establish a single column so the clipped overflow behaves the same way.
+  const columnStyle = columns ? {
+    columnCount: columns.count,
+    columnWidth: columns.width,
+    columnGap: columns.gap
+  } : undefined;
+
+  // A glyph's side bearings — ink that sits outside its advance width, like a
+  // leading lowercase 'j' or an italic overhang — would be shorn by the inline
+  // clip. Per-glyph bearings aren't in the font metrics, so reserve a flat 0.1em
+  // on each inline edge and cancel it with a negative margin so
+  // wrapping and text position stay put.
+  const sideBearing = shouldTruncate ? '0.1em' : '0px';
   const style = {
     fontSize: autofit ? `${size}px` : `calc(var(--type-tester--adjustment, 1) * ${size}px)`,
     lineHeight: `${lineHeight}`,
-    // Reserve exactly `truncateLines` lines so the height is predictable and
-    // side-by-side testers keep their toolbars aligned, then clip the overflow.
-    height: shouldTruncate ? `${size * lineHeight * truncateLines}px` : 'auto',
-    overflow: shouldTruncate ? 'hidden' : 'visible',
-    ...(ellipsis && {
-      display: '-webkit-box',
-      WebkitBoxOrient: 'vertical',
-      WebkitLineClamp: truncateLines
+    ...(shouldTruncate ? {
+      // Cap each column at `truncateLines` lines. `max-height` (not `height`)
+      // lets shorter paragraphs collapse to their content instead of padding
+      // out to N lines of whitespace. Columns send the clipped overflow
+      // sideways (into off-screen columns) rather than below, so the last
+      // visible line of every column is never partially covered by the next
+      // one. That lets the symmetric `lineOverflowEm` padding fully reveal the
+      // first line's ascenders/accents and the last line's descenders at any
+      // line-height; the negative margins cancel that padding in layout so a
+      // collapsed paragraph still occupies exactly its line count.
+      //
+      // Everything is in `em` so it tracks the rendered font-size (including
+      // the mobile `--type-tester--adjustment`); the `+ 2px` is slack that
+      // keeps sub-pixel rounding from dropping the Nth line (the extra never
+      // reveals line N+1 because that line is clipped out to the side).
+      boxSizing: 'border-box',
+      maxHeight: `calc(${truncateLines * lineHeight + 2 * lineOverflowEm}em + 2px)`,
+      paddingTop: `${lineOverflowEm}em`,
+      paddingBottom: `${lineOverflowEm}em`,
+      paddingLeft: sideBearing,
+      paddingRight: sideBearing,
+      marginTop: `${-lineOverflowEm}em`,
+      marginBottom: `${-lineOverflowEm}em`,
+      overflow: 'hidden',
+      // Fill each column to its full N lines before spilling to the next, and
+      // allow a final column with a single line — otherwise the default
+      // `widows: 2` / `column-fill: balance` rebalance a 4-line paragraph into
+      // two columns of 2, showing N−1 lines instead of N.
+      columnFill: 'auto',
+      widows: 1,
+      orphans: 1,
+      ...(columnStyle ?? {
+        columnCount: 1
+      })
+    } : {
+      height: 'auto',
+      overflow: 'visible',
+      ...columnStyle
     }),
     fontFeatureSettings,
-    marginRight: alignment !== 'right' ? -sideBuffer : 0,
-    marginLeft: alignment === 'right' ? -sideBuffer : 0,
+    marginRight: `calc(${alignment !== 'right' ? -sideBuffer : 0}px - ${sideBearing})`,
+    marginLeft: `calc(${alignment === 'right' ? -sideBuffer : 0}px - ${sideBearing})`,
     letterSpacing: `${letterSpacing}em`,
     fontVariationSettings,
-    textAlign: alignment,
-    ...(columns && {
-      columnCount: columns.count,
-      columnWidth: columns.width,
-      columnGap: columns.gap
-    })
+    textAlign: alignment
   };
   return {
     ref,

package/dist/components/TypeTesters/index.d.ts

@@ -3,7 +3,7 @@ import { TypeTestersIDQuery } from '../../__generated__/TypeTestersIDQuery.graph
 import { TypeTestersSlugQuery } from '../../__generated__/TypeTestersSlugQuery.graphql.js';
 import { Config } from '../ConfigContext.js';
 import { FeaturesProp } from '../TypeTester/types.js';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { SerializablePreloadedQuery, type LoadQueryOptions } from '../../relay/loadSerializableQuery.js';
 export interface TypeTesters_props {
     collectionId?: string;
     collectionSlug?: string;
@@ -33,7 +33,7 @@ export type LoadTypeTestersQueryVariables = ({
     tags?: string[] | null;
     excludeTags?: string[] | null;
 };
-export declare function loadTypeTestersQuery(variables: LoadTypeTestersQueryVariables): Promise<TypeTestersPreloadedQuery>;
+export declare function loadTypeTestersQuery(variables: LoadTypeTestersQueryVariables, options?: LoadQueryOptions): Promise<TypeTestersPreloadedQuery>;
 export type TypeTesters_unifiedProps = TypeTesters_props & {
     preloadedQuery?: TypeTestersPreloadedQuery;
     config?: Config;

package/dist/components/TypeTesters/index.js

@@ -251,7 +251,7 @@ function TypeTestersSlugQueryRenderer(_ref6) {
     excludeTags: excludeTags
   }));
 }
-export async function loadTypeTestersQuery(variables) {
+export async function loadTypeTestersQuery(variables, options) {
   const tags = variables.tags ?? null;
   const excludeTags = variables.excludeTags ?? null;
   if (variables.collectionId) {
@@ -259,14 +259,14 @@ export async function loadTypeTestersQuery(variables) {
       collectionId: variables.collectionId,
       tags,
       excludeTags
-    });
+    }, options);
   }
   if (variables.collectionSlug) {
     return loadSerializableQuery(TypeTestersSlugQueryNode, {
       collectionSlug: variables.collectionSlug,
       tags,
       excludeTags
-    });
+    }, options);
   }
   throw new Error('loadTypeTestersQuery expected either collectionId or collectionSlug');
 }

package/dist/components/elements/StoreModalUnifiedCheckout.js

@@ -75,6 +75,7 @@ import StripeLogo from '../StripeLogo.js';
 import { Check, X } from '../Icons/index.js';
 import ConfigContext from '../ConfigContext.js';
 import { Price } from '../Price/index.js';
+import { sendOrderTracking } from '../Cart/orderTracking.js';
 
 /* const LICENSEE_REQUIRED_FIELDS = ['organization', 'country'] as (keyof Identity)[]; */
 
@@ -274,6 +275,13 @@ export default function StoreModalUnifiedCheckout(_ref2) {
     }));
   }, [setLicenseeIdentity]);
   const environment = useRelayEnvironment();
+
+  // Capture analytics consent + attribution on the order for the purchase
+  // event the server emits on completion (from a Stripe webhook, where no
+  // browser context exists).
+  useEffect(() => {
+    sendOrderTracking(environment);
+  }, [environment]);
   const [error, setError] = useState(null);
   const [errorsObject, setErrorsObject] = useState(null);
   const [customerErrorsObject, setCustomerErrorsObject] = useState(null);

package/dist/components/useFontStyle.d.ts

@@ -3,8 +3,16 @@ import { useFontStyle_fontStyle$key } from '../__generated__/useFontStyle_fontSt
 interface UseFontStyle_props {
     fontStyle: useFontStyle_fontStyle$key | null | undefined;
 }
+export type VerticalMetrics = {
+    readonly unitsPerEm: number;
+    readonly ascender: number;
+    readonly descender: number;
+    readonly lineGap: number | null;
+    readonly avgCharWidth: number | null;
+};
 declare const useFontStyle: ({ fontStyle: fontStyleKey, }: UseFontStyle_props) => {
     style: React.CSSProperties;
     loaded: boolean;
+    verticalMetrics: VerticalMetrics | null;
 };
 export default useFontStyle;

package/dist/components/useFontStyle.js

@@ -2,12 +2,13 @@ import _useFontStyle_fontStyle from "../__generated__/useFontStyle_fontStyle.gra
 import { useState, useRef, useEffect } from 'react';
 import { graphql, useFragment } from 'react-relay';
 import { loadFont, isFontLoaded } from '../fontLoader.js';
+import { ensureMetricFallback, metricFallbackFamily } from '../metricFallback.js';
 const FALLBACK_FAMILY = 'Fallback';
 const useFontStyle = _ref => {
   let {
     fontStyle: fontStyleKey
   } = _ref;
-  const fontStyle = useFragment((_useFontStyle_fontStyle.hash && _useFontStyle_fontStyle.hash !== "df4c7160c29373e86bea8b6082d19994" && console.error("The definition of 'useFontStyle_fontStyle' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _useFontStyle_fontStyle), fontStyleKey ?? null);
+  const fontStyle = useFragment((_useFontStyle_fontStyle.hash && _useFontStyle_fontStyle.hash !== "171c546f40909692656c5e143a98d8a3" && console.error("The definition of 'useFontStyle_fontStyle' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _useFontStyle_fontStyle), fontStyleKey ?? null);
   const fontFamily = fontStyle ? `${fontStyle.cssFamily} ${fontStyle.name}` : null;
   const sources = fontStyle === null || fontStyle === void 0 ? void 0 : fontStyle.webfontSources;
   const verticalMetrics = fontStyle === null || fontStyle === void 0 ? void 0 : fontStyle.verticalMetrics;
@@ -24,6 +25,10 @@ const useFontStyle = _ref => {
   }, []);
   useEffect(() => {
     if (!fontFamily) return;
+
+    // Register a metric-matched fallback so the placeholder dots occupy this
+    // font's box (no reflow on swap-in, matched dots for missing glyphs).
+    if (verticalMetrics) ensureMetricFallback(fontFamily, verticalMetrics);
     if (isFontLoaded(fontFamily)) {
       setLoaded(true);
       return;
@@ -34,18 +39,23 @@ const useFontStyle = _ref => {
       if (mounted.current) setLoaded(true);
     }).catch(console.error);
   }, [fontFamily]);
+
+  // Prefer the metric-matched fallback (when this font has metrics), with the
+  // generic Fallback as the ultimate catch-all.
+  const fallbackChain = fontFamily && verticalMetrics && verticalMetrics.unitsPerEm > 0 ? `"${metricFallbackFamily(fontFamily)}", ${FALLBACK_FAMILY}` : FALLBACK_FAMILY;
   const cssStyle = loaded && fontFamily ? {
-    fontFamily: `"${fontFamily}", ${FALLBACK_FAMILY}`,
+    fontFamily: `"${fontFamily}", ${fallbackChain}`,
     fontWeight: 400,
     fontStyle: 'normal'
   } : {
-    fontFamily: FALLBACK_FAMILY,
+    fontFamily: fallbackChain,
     fontWeight: 'normal',
     fontStyle: 'normal'
   };
   return {
     style: cssStyle,
-    loaded
+    loaded,
+    verticalMetrics: verticalMetrics ?? null
   };
 };
 export default useFontStyle;

package/dist/corsError.d.ts

@@ -1,6 +1,2 @@
-export declare function setCorsModalEnabled(enabled: boolean): void;
-export interface CorsError {
-    origin: string;
-    fontdueUrl: string;
-}
+export declare function setConnectionErrorUiEnabled(enabled: boolean): void;
 export declare function handlePossibleCorsError(error: unknown, fetchUrl: string): boolean;

package/dist/corsError.js

@@ -1,9 +1,14 @@
 import retryImport from './retryImport.js';
 let detected = false;
 let navigating = false;
-let modalEnabled = true;
-export function setCorsModalEnabled(enabled) {
-  modalEnabled = enabled;
+let connectionErrorUiEnabled = true;
+
+// Gate for the visible connection-error UI (the admin toolbar's status). Wired
+// from the `corsErrorModal` config option (legacy name, kept for
+// compatibility). When disabled we still log and keep polling for recovery — we
+// just never publish a status for the toolbar to surface.
+export function setConnectionErrorUiEnabled(enabled) {
+  connectionErrorUiEnabled = enabled;
 }
 if (typeof window !== 'undefined') {
   window.addEventListener('beforeunload', () => {
@@ -45,17 +50,22 @@ async function isCorsBlocked(fetchUrl) {
     return false; // server unreachable, network error
   }
 }
-function showCorsError(origin, fetchUrl) {
-  console.error(`[Fontdue] Cross-origin request to ${fetchUrl} was blocked.\n\n` + `Your website (${origin}) is not listed as an allowed origin ` + `in your Fontdue CORS settings.\n\n` + `To fix this:\n` + `1. Log in to your Fontdue dashboard\n` + `2. Go to Settings \u2192 Security\n` + `3. Add "${origin}" to the "Cross-origin API access" field\n` + `4. Save \u2014 this page will reload automatically`);
-  if (modalEnabled) {
-    retryImport(() => import('./components/CorsErrorModal.js')).then(_ref => {
+function publishConnectionError(origin, fetchUrl) {
+  console.error(`[Fontdue] Cross-origin request to ${fetchUrl} was blocked.\n\n` + `Your website (${origin}) is most likely not listed as an allowed ` + `origin in your Fontdue settings.\n\n` + `To fix this:\n` + `1. Log in to your Fontdue dashboard\n` + `2. Go to Settings → Integration\n` + `3. Add "${origin}" to your allowed origins\n` + `4. Save — this page will reload automatically\n\n` + `If "${origin}" is already listed, the connection may be failing for ` + `another reason (a network problem or a temporary Fontdue outage).`);
+
+  // Surface the connection status as a compact, toolbar-styled widget (red
+  // button + alert glyph) rather than the old full-screen modal. It mounts in
+  // its own React root — see ConnectionErrorToolbar for why it isn't part of
+  // the in-tree admin toolbar.
+  if (connectionErrorUiEnabled) {
+    retryImport(() => import('./components/ConnectionErrorToolbar.js')).then(_ref => {
       let {
-        renderCorsErrorModal
+        renderConnectionErrorToolbar
       } = _ref;
-      renderCorsErrorModal(origin, fetchUrl);
+      renderConnectionErrorToolbar(origin, fetchUrl);
     }).catch(() => {
-      // Chunk failed to load — the console.error above already
-      // told the developer what's wrong.
+      // Chunk failed to load — the console.error above already told the
+      // developer what's wrong.
     });
   }
   startPolling(fetchUrl);
@@ -72,10 +82,10 @@ export function handlePossibleCorsError(error, fetchUrl) {
   // Verify this is actually a CORS error and not a network failure.
   // We do this async — handlePossibleCorsError still returns true
   // synchronously so the caller can return a stub response instead
-  // of throwing, but we only show the modal if CORS is confirmed.
+  // of throwing, but we only surface a status if CORS is confirmed.
   isCorsBlocked(fetchUrl).then(blocked => {
     if (blocked) {
-      showCorsError(origin, fetchUrl);
+      publishConnectionError(origin, fetchUrl);
     } else {
       // Network error, not CORS — reset so a real CORS error
       // can still be detected if connectivity recovers.

package/dist/data/unicodeNamesUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const FONTDUE_CDN_URL = "https://cdn.fontdue.com";
+export declare function unicodeNamesUrl(cdnUrl?: string): string;

package/dist/data/unicodeNamesUrl.js

@@ -0,0 +1,18 @@
+import { UNICODE_NAMES_VERSION } from './unicodeNamesVersion.js';
+
+// The unicode code-point→name map (~1.2 MB) is not bundled — it's served as a
+// static, immutable JSON asset from the Fontdue CDN and fetched at runtime by
+// CharacterViewer. The filename is content-hashed (UNICODE_NAMES_VERSION) so it
+// can be cached forever; a data change produces a new filename.
+//
+// The asset is uploaded to the CDN under `/js/dist/` by the data-refresh flow
+// (`npm run update-unicode-data`, which also runs `npm run publish-unicode-data`)
+// — not by the npm publish or the app deploy. See fontdue-js/src/scripts.
+//
+// `/js/dist/` is the path every Fontdue CDN asset is served from on the cdn.*
+// hosts (the bucket's `js/` prefix served at root); it is NOT a bare `/dist/`.
+export const FONTDUE_CDN_URL = 'https://cdn.fontdue.com';
+export function unicodeNamesUrl() {
+  let cdnUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : FONTDUE_CDN_URL;
+  return `${cdnUrl.replace(/\/+$/, '')}/js/dist/unicode-names.${UNICODE_NAMES_VERSION}.json`;
+}

package/dist/data/unicodeNamesVersion.d.ts

@@ -0,0 +1 @@
+export declare const UNICODE_NAMES_VERSION = "3132bac0592155bd";

package/dist/data/unicodeNamesVersion.js

@@ -0,0 +1,4 @@
+// Generated by `npm run update-unicode-data`. Content hash of unicodeNames.json.
+// Both the CDN asset filename and the runtime fetch URL derive from this, so
+// they always agree. Do not edit by hand.
+export const UNICODE_NAMES_VERSION = "3132bac0592155bd";

package/dist/fallbackFontData.d.ts

@@ -0,0 +1,2 @@
+export declare const FALLBACK_FONT_WOFF2_BASE64 = "d09GMgABAAAAAADYAAoAAAAAAfAAAACQAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk4AKAoYNwsGAAE2AiQDBgQgBQYHIBtSAciuDmzHfIwcg7zyGj36BfE8dGnv70xqs5AX4ZCucZY0yTXRgFyjzRELyQwA4SlI9ET4Ii+c/07ghH6YVABETR5hoAGnbXd2cSn13Et3RDHF3AIcAQHrPgIaUBFUDAEVkHqdmd4ObdsCQfj6X6u/lfICANClyCgaEMqrR546XQgAIHmiEzSqgAYAAAwVAAAA";
+export declare const FALLBACK_ADVANCE_PER_EM = 0.458;

package/dist/fallbackFontData.js

@@ -0,0 +1,10 @@
+// Generated by scripts/generate_fallback_font.py — do not edit by hand.
+//
+// The universal minimal fallback font (renders a dot for every Unicode
+// codepoint), embedded as base64 so per-family metric-matched fallbacks can
+// be built at runtime via the FontFace API (see metricFallback.ts).
+export const FALLBACK_FONT_WOFF2_BASE64 = 'd09GMgABAAAAAADYAAoAAAAAAfAAAACQAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk4AKAoYNwsGAAE2AiQDBgQgBQYHIBtSAciuDmzHfIwcg7zyGj36BfE8dGnv70xqs5AX4ZCucZY0yTXRgFyjzRELyQwA4SlI9ET4Ii+c/07ghH6YVABETR5hoAGnbXd2cSn13Et3RDHF3AIcAQHrPgIaUBFUDAEVkHqdmd4ObdsCQfj6X6u/lfICANClyCgaEMqrR546XQgAIHmiEzSqgAYAAAwVAAAA';
+
+// The dot font's intrinsic average advance, in em — every glyph advances
+// 458/1000 em. Used as the denominator when computing `size-adjust`.
+export const FALLBACK_ADVANCE_PER_EM = 0.458;