@pro-laico/payload-fonts 0.0.0

package/dist/fields/font.js

@@ -0,0 +1,37 @@
+import { resolveFontFamilies } from "../lib/families.js";
+/**
+ * The per-family relationship fields for the `fontSet` global — one slot per configured family
+ * (`sans / serif / mono / display` by default), pointing at this package's `font` typeface
+ * collection and laid out two-per-row. Used by the standalone `fontSet` global
+ * (`globals/fontSet.ts`), and exported so a project assembling its own selection surface (a
+ * different global, or a group on an existing collection) can reuse the exact same slots.
+ */ export const fontUploadFields = ({ fontSlug = 'font', families } = {})=>{
+    const relationTo = fontSlug;
+    const resolved = resolveFontFamilies(families);
+    // Each slot selects ONE typeface (`font`) whose `family` family matches. A typeface carries its
+    // own weight files, which the download generator collapses into a single `next/font/local`
+    // declaration (one `src` per file). The slot is a single relationship — the multiplicity
+    // lives inside the typeface, not here.
+    const slots = resolved.map((family)=>({
+            name: family.key,
+            label: family.label,
+            type: 'relationship',
+            relationTo,
+            filterOptions: {
+                family: {
+                    equals: family.key
+                }
+            }
+        }));
+    // Lay the slots out two per row, matching the original sans/serif | mono/display grid.
+    const rows = [];
+    for(let i = 0; i < slots.length; i += 2){
+        rows.push({
+            type: 'row',
+            fields: slots.slice(i, i + 2)
+        });
+    }
+    return rows;
+};
+
+//# sourceMappingURL=font.js.map

package/dist/fields/font.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fields/font.ts"],"sourcesContent":["import type { CollectionSlug, Field } from 'payload'\n\nimport { type FontFamilyConfig, resolveFontFamilies } from '../lib/families'\n\n/**\n * The per-family relationship fields for the `fontSet` global — one slot per configured family\n * (`sans / serif / mono / display` by default), pointing at this package's `font` typeface\n * collection and laid out two-per-row. Used by the standalone `fontSet` global\n * (`globals/fontSet.ts`), and exported so a project assembling its own selection surface (a\n * different global, or a group on an existing collection) can reuse the exact same slots.\n */\nexport const fontUploadFields = ({ fontSlug = 'font', families }: { fontSlug?: string; families?: FontFamilyConfig[] } = {}): Field[] => {\n  const relationTo = fontSlug as CollectionSlug\n  const resolved = resolveFontFamilies(families)\n  // Each slot selects ONE typeface (`font`) whose `family` family matches. A typeface carries its\n  // own weight files, which the download generator collapses into a single `next/font/local`\n  // declaration (one `src` per file). The slot is a single relationship — the multiplicity\n  // lives inside the typeface, not here.\n  const slots: Field[] = resolved.map((family) => ({\n    name: family.key,\n    label: family.label,\n    type: 'relationship',\n    relationTo,\n    filterOptions: { family: { equals: family.key } },\n  }))\n\n  // Lay the slots out two per row, matching the original sans/serif | mono/display grid.\n  const rows: Field[] = []\n  for (let i = 0; i < slots.length; i += 2) {\n    rows.push({ type: 'row', fields: slots.slice(i, i + 2) })\n  }\n  return rows\n}\n"],"names":["resolveFontFamilies","fontUploadFields","fontSlug","families","relationTo","resolved","slots","map","family","name","key","label","type","filterOptions","equals","rows","i","length","push","fields","slice"],"mappings":"AAEA,SAAgCA,mBAAmB,QAAQ,qBAAiB;AAE5E;;;;;;CAMC,GACD,OAAO,MAAMC,mBAAmB,CAAC,EAAEC,WAAW,MAAM,EAAEC,QAAQ,EAAwD,GAAG,CAAC,CAAC;IACzH,MAAMC,aAAaF;IACnB,MAAMG,WAAWL,oBAAoBG;IACrC,gGAAgG;IAChG,2FAA2F;IAC3F,yFAAyF;IACzF,uCAAuC;IACvC,MAAMG,QAAiBD,SAASE,GAAG,CAAC,CAACC,SAAY,CAAA;YAC/CC,MAAMD,OAAOE,GAAG;YAChBC,OAAOH,OAAOG,KAAK;YACnBC,MAAM;YACNR;YACAS,eAAe;gBAAEL,QAAQ;oBAAEM,QAAQN,OAAOE,GAAG;gBAAC;YAAE;QAClD,CAAA;IAEA,uFAAuF;IACvF,MAAMK,OAAgB,EAAE;IACxB,IAAK,IAAIC,IAAI,GAAGA,IAAIV,MAAMW,MAAM,EAAED,KAAK,EAAG;QACxCD,KAAKG,IAAI,CAAC;YAAEN,MAAM;YAAOO,QAAQb,MAAMc,KAAK,CAACJ,GAAGA,IAAI;QAAG;IACzD;IACA,OAAOD;AACT,EAAC"}

package/dist/globals/fontSet.d.ts

@@ -0,0 +1,15 @@
+import type { GlobalConfig } from 'payload';
+import type { FontFamilyConfig } from '../lib/families';
+/** Slug of the standalone font-selection global. */
+export declare const FONT_SET_SLUG = "fontSet";
+/**
+ * A singleton global holding the active font choices — one slot per configured family (sans /
+ * serif / mono / display by default). The fonts export endpoint reads it to resolve which
+ * typefaces to ship, so a project can drive `next/font/local` from a CMS-managed selection.
+ * Registered by `fontsPlugin()` by default (pass `includeFontSet: false` to skip it).
+ */
+export declare const createFontSetGlobal: ({ fontSlug, families, }?: {
+    fontSlug?: string;
+    families?: FontFamilyConfig[];
+}) => GlobalConfig;
+//# sourceMappingURL=fontSet.d.ts.map

package/dist/globals/fontSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontSet.d.ts","sourceRoot":"","sources":["../../src/globals/fontSet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAI3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEvD,oDAAoD;AACpD,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,0BAGjC;IACD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAA;CACzB,KAAG,YASP,CAAA"}

package/dist/globals/fontSet.js

@@ -0,0 +1,25 @@
+import { authd } from "../access/authd.js";
+import { fontUploadFields } from "../fields/font.js";
+/** Slug of the standalone font-selection global. */ export const FONT_SET_SLUG = 'fontSet';
+/**
+ * A singleton global holding the active font choices — one slot per configured family (sans /
+ * serif / mono / display by default). The fonts export endpoint reads it to resolve which
+ * typefaces to ship, so a project can drive `next/font/local` from a CMS-managed selection.
+ * Registered by `fontsPlugin()` by default (pass `includeFontSet: false` to skip it).
+ */ export const createFontSetGlobal = ({ fontSlug = 'font', families } = {})=>({
+        slug: FONT_SET_SLUG,
+        admin: {
+            group: 'Assets',
+            description: 'Choose which uploaded typeface fills each slot. This is what actually puts a font on your site — upload in Font first, then activate it here.'
+        },
+        access: {
+            read: authd,
+            update: authd
+        },
+        fields: fontUploadFields({
+            fontSlug,
+            families
+        })
+    });
+
+//# sourceMappingURL=fontSet.js.map

package/dist/globals/fontSet.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/globals/fontSet.ts"],"sourcesContent":["import type { GlobalConfig } from 'payload'\n\nimport { authd } from '../access/authd'\nimport { fontUploadFields } from '../fields/font'\nimport type { FontFamilyConfig } from '../lib/families'\n\n/** Slug of the standalone font-selection global. */\nexport const FONT_SET_SLUG = 'fontSet'\n\n/**\n * A singleton global holding the active font choices — one slot per configured family (sans /\n * serif / mono / display by default). The fonts export endpoint reads it to resolve which\n * typefaces to ship, so a project can drive `next/font/local` from a CMS-managed selection.\n * Registered by `fontsPlugin()` by default (pass `includeFontSet: false` to skip it).\n */\nexport const createFontSetGlobal = ({\n  fontSlug = 'font',\n  families,\n}: {\n  fontSlug?: string\n  families?: FontFamilyConfig[]\n} = {}): GlobalConfig => ({\n  slug: FONT_SET_SLUG,\n  admin: {\n    group: 'Assets',\n    description:\n      'Choose which uploaded typeface fills each slot. This is what actually puts a font on your site — upload in Font first, then activate it here.',\n  },\n  access: { read: authd, update: authd },\n  fields: fontUploadFields({ fontSlug, families }),\n})\n"],"names":["authd","fontUploadFields","FONT_SET_SLUG","createFontSetGlobal","fontSlug","families","slug","admin","group","description","access","read","update","fields"],"mappings":"AAEA,SAASA,KAAK,QAAQ,qBAAiB;AACvC,SAASC,gBAAgB,QAAQ,oBAAgB;AAGjD,kDAAkD,GAClD,OAAO,MAAMC,gBAAgB,UAAS;AAEtC;;;;;CAKC,GACD,OAAO,MAAMC,sBAAsB,CAAC,EAClCC,WAAW,MAAM,EACjBC,QAAQ,EAIT,GAAG,CAAC,CAAC,GAAoB,CAAA;QACxBC,MAAMJ;QACNK,OAAO;YACLC,OAAO;YACPC,aACE;QACJ;QACAC,QAAQ;YAAEC,MAAMX;YAAOY,QAAQZ;QAAM;QACrCa,QAAQZ,iBAAiB;YAAEG;YAAUC;QAAS;IAChD,CAAA,EAAE"}

package/dist/hooks/optimizeFont.d.ts

@@ -0,0 +1,56 @@
+/** The subsetter charset: a built-in preset name, or an explicit string of characters to keep. */
+export type Charset = 'latin' | 'latin-ext' | (string & {});
+/**
+ * Resolve a charset option to the set of characters the subsetter should keep. A known
+ * preset name ('latin' | 'latin-ext') expands to its ranges; any other string is treated
+ * as an explicit, verbatim list of characters to retain.
+ */
+export declare const resolveCharsetText: (charset?: Charset) => string;
+/** What {@link detectMetadata} reads out of a font binary. */
+export interface FontFileMetadata {
+    familyName?: string;
+    weight?: string;
+    style?: 'normal' | 'italic';
+    isVariable: boolean;
+    /** The file ALSO carries italics through a variation axis (an `ital` axis reaching 1, or a
+     *  negative `slnt` range) while its default instance is upright — one file, both styles. */
+    italCapable?: boolean;
+    /** For `slnt`-based italics: the positive CSS oblique angle (deg) matching the axis extreme. */
+    obliqueAngle?: number;
+}
+/**
+ * Best-effort read of weight / style / family from a font's metadata via the bundled
+ * `fontkit` dependency. Returns `null` when the font can't be parsed.
+ *
+ * A `wght` variation axis marks a variable font: we keep its full `min max` range (e.g.
+ * `'100 900'`) — exactly what `next/font/local` expects — instead of clamping to the
+ * single default-instance weight class as we do for static fonts.
+ *
+ * An upright variable file whose axes ALSO cover italics — a true `ital` axis reaching 1, or a
+ * `slnt` axis leaning forward (negative min) — is flagged `italCapable`, so the serving layers
+ * can emit an italic `@font-face` from the same file (CSS maps `font-style: italic` onto `ital`
+ * and `font-style: oblique <angle>` onto `slnt`).
+ */
+export declare function detectMetadata(buffer: Buffer): Promise<FontFileMetadata | null>;
+/**
+ * Subset a font buffer to a WOFF2 using the bundled `subset-font` (harfbuzz). Variable
+ * axes are preserved (harfbuzz keeps `fvar`/`gvar` unless axes are explicitly pinned), so
+ * a variable font stays variable through the subset.
+ */
+export declare function subsetToWoff2(buffer: Buffer, charsetText: string): Promise<Buffer>;
+/**
+ * The most common deployment mistake: a bundler (Next/Turbopack) bundles the harfbuzz / fontkit
+ * wasm + native assets, rewriting their load paths to virtual ones that don't exist on disk. The
+ * subset then throws at runtime, fonts upload but never get subsetted, and nothing is served.
+ * True when an error is that load failure (vs. an ordinary bad-font error).
+ */
+export declare const isSubsetterLoadError: (err: unknown) => boolean;
+/**
+ * Boot-time probe for that mistake. Importing `subset-font` is NOT enough to detect it — harfbuzz
+ * reads its wasm lazily (`_.once`) on the FIRST SUBSET CALL — so this runs a real subset on a
+ * garbage buffer: the wasm loads (and fails loudly if bundled) before the buffer is ever parsed.
+ * Resolves `null` when the subsetter is healthy — a bad-font error from the garbage buffer proves
+ * the wasm loaded — or the load error for the caller to report.
+ */
+export declare function probeSubsetter(): Promise<unknown | null>;
+//# sourceMappingURL=optimizeFont.d.ts.map

package/dist/hooks/optimizeFont.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizeFont.d.ts","sourceRoot":"","sources":["../../src/hooks/optimizeFont.ts"],"names":[],"mappings":"AAiCA,kGAAkG;AAClG,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAQ3D;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAS,OAAiB,KAAG,MAG/D,CAAA;AAqBD,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC3B,UAAU,EAAE,OAAO,CAAA;IACnB;gGAC4F;IAC5F,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAwCrF;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxF;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,OAAO,KAAG,OAMnD,CAAA;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAO9D"}

package/dist/hooks/optimizeFont.js

@@ -0,0 +1,185 @@
+/**
+ * Built-in charset presets, expressed as inclusive Unicode code-point ranges. Each
+ * preset is expanded to a string of characters that the subsetter keeps; everything
+ * else is dropped to shrink the file.
+ */ const CHARSET_PRESETS = {
+    // Printable ASCII + Latin-1 Supplement (Western-European accents: é ñ ü ç …) plus the
+    // typographic punctuation CMS/word-processor content relies on (curly quotes, en/em
+    // dashes, ellipsis, €, ™) so common copy doesn't fall back.
+    latin: [
+        [
+            0x20,
+            0x7e
+        ],
+        [
+            0xa0,
+            0xff
+        ],
+        [
+            0x2010,
+            0x2014
+        ],
+        [
+            0x2018,
+            0x201f
+        ],
+        [
+            0x2022,
+            0x2022
+        ],
+        [
+            0x2026,
+            0x2026
+        ],
+        [
+            0x20ac,
+            0x20ac
+        ],
+        [
+            0x2122,
+            0x2122
+        ]
+    ],
+    // Everything in `latin` plus Latin Extended-A/B (Central/Eastern-European: ą ž ł ő …).
+    'latin-ext': [
+        [
+            0x20,
+            0x7e
+        ],
+        [
+            0xa0,
+            0xff
+        ],
+        [
+            0x100,
+            0x24f
+        ],
+        [
+            0x2010,
+            0x2014
+        ],
+        [
+            0x2018,
+            0x201f
+        ],
+        [
+            0x2022,
+            0x2022
+        ],
+        [
+            0x2026,
+            0x2026
+        ],
+        [
+            0x20ac,
+            0x20ac
+        ],
+        [
+            0x2122,
+            0x2122
+        ]
+    ]
+};
+const rangesToText = (ranges)=>{
+    let text = '';
+    for (const [start, end] of ranges)for(let cp = start; cp <= end; cp++)text += String.fromCodePoint(cp);
+    return text;
+};
+/**
+ * Resolve a charset option to the set of characters the subsetter should keep. A known
+ * preset name ('latin' | 'latin-ext') expands to its ranges; any other string is treated
+ * as an explicit, verbatim list of characters to retain.
+ */ export const resolveCharsetText = (charset = 'latin')=>{
+    const preset = CHARSET_PRESETS[charset];
+    return preset ? rangesToText(preset) : charset;
+};
+/** Clamp an arbitrary OS/2 weight class to the nearest standard 100–900 step. */ const normalizeWeight = (weight)=>{
+    if (!weight || Number.isNaN(weight)) return undefined;
+    return String(Math.min(900, Math.max(100, Math.round(weight / 100) * 100)));
+};
+/**
+ * Best-effort read of weight / style / family from a font's metadata via the bundled
+ * `fontkit` dependency. Returns `null` when the font can't be parsed.
+ *
+ * A `wght` variation axis marks a variable font: we keep its full `min max` range (e.g.
+ * `'100 900'`) — exactly what `next/font/local` expects — instead of clamping to the
+ * single default-instance weight class as we do for static fonts.
+ *
+ * An upright variable file whose axes ALSO cover italics — a true `ital` axis reaching 1, or a
+ * `slnt` axis leaning forward (negative min) — is flagged `italCapable`, so the serving layers
+ * can emit an italic `@font-face` from the same file (CSS maps `font-style: italic` onto `ital`
+ * and `font-style: oblique <angle>` onto `slnt`).
+ */ export async function detectMetadata(buffer) {
+    try {
+        // fontkit v2 ships `create` as a NAMED export under node's ESM interop (no usable
+        // `default`), but bundlers may synthesize a default — accept either, or detection
+        // silently no-ops and weight/style/family never autofill.
+        const mod = await import("fontkit");
+        const create = mod.create ?? mod.default?.create;
+        if (!create) return null;
+        const font = create(buffer);
+        const italic = Boolean(typeof font.italicAngle === 'number' && font.italicAngle !== 0 || (font['OS/2']?.fsSelection ?? 0) & 0x01 || /italic|oblique/i.test(font.subfamilyName ?? ''));
+        const wght = font.variationAxes?.wght;
+        const weight = wght ? `${Math.round(wght.min)} ${Math.round(wght.max)}` : normalizeWeight(font['OS/2']?.usWeightClass);
+        let italCapable;
+        let obliqueAngle;
+        if (!italic) {
+            const ital = font.variationAxes?.ital;
+            const slnt = font.variationAxes?.slnt;
+            if (ital && ital.max >= 1) italCapable = true;
+            else if (slnt && slnt.min < 0) {
+                italCapable = true;
+                obliqueAngle = Math.round(Math.abs(slnt.min));
+            }
+        }
+        return {
+            familyName: font.familyName ?? undefined,
+            weight,
+            style: italic ? 'italic' : 'normal',
+            isVariable: Boolean(wght),
+            ...italCapable ? {
+                italCapable
+            } : {},
+            ...obliqueAngle ? {
+                obliqueAngle
+            } : {}
+        };
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Subset a font buffer to a WOFF2 using the bundled `subset-font` (harfbuzz). Variable
+ * axes are preserved (harfbuzz keeps `fvar`/`gvar` unless axes are explicitly pinned), so
+ * a variable font stays variable through the subset.
+ */ export async function subsetToWoff2(buffer, charsetText) {
+    const subsetFont = (await import("subset-font")).default;
+    return subsetFont(buffer, charsetText, {
+        targetFormat: 'woff2'
+    });
+}
+/**
+ * The most common deployment mistake: a bundler (Next/Turbopack) bundles the harfbuzz / fontkit
+ * wasm + native assets, rewriting their load paths to virtual ones that don't exist on disk. The
+ * subset then throws at runtime, fonts upload but never get subsetted, and nothing is served.
+ * True when an error is that load failure (vs. an ordinary bad-font error).
+ */ export const isSubsetterLoadError = (err)=>{
+    const msg = err instanceof Error ? `${err.message}\n${err.stack ?? ''}` : String(err);
+    return /(hb-subset\.wasm|harfbuzzjs|subset-font|fontkit)/i.test(msg) && /(ENOENT|no such file|cannot find module|failed to load|MODULE_NOT_FOUND)/i.test(msg);
+};
+/**
+ * Boot-time probe for that mistake. Importing `subset-font` is NOT enough to detect it — harfbuzz
+ * reads its wasm lazily (`_.once`) on the FIRST SUBSET CALL — so this runs a real subset on a
+ * garbage buffer: the wasm loads (and fails loudly if bundled) before the buffer is ever parsed.
+ * Resolves `null` when the subsetter is healthy — a bad-font error from the garbage buffer proves
+ * the wasm loaded — or the load error for the caller to report.
+ */ export async function probeSubsetter() {
+    try {
+        await subsetToWoff2(Buffer.from('not a font'), 'a');
+    } catch (err) {
+        if (isSubsetterLoadError(err)) return err;
+    }
+    return null;
+}
+
+//# sourceMappingURL=optimizeFont.js.map

package/dist/hooks/optimizeFont.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/optimizeFont.ts"],"sourcesContent":["/**\n * Built-in charset presets, expressed as inclusive Unicode code-point ranges. Each\n * preset is expanded to a string of characters that the subsetter keeps; everything\n * else is dropped to shrink the file.\n */\nconst CHARSET_PRESETS: Record<string, Array<[number, number]>> = {\n  // Printable ASCII + Latin-1 Supplement (Western-European accents: é ñ ü ç …) plus the\n  // typographic punctuation CMS/word-processor content relies on (curly quotes, en/em\n  // dashes, ellipsis, €, ™) so common copy doesn't fall back.\n  latin: [\n    [0x20, 0x7e],\n    [0xa0, 0xff],\n    [0x2010, 0x2014],\n    [0x2018, 0x201f],\n    [0x2022, 0x2022],\n    [0x2026, 0x2026],\n    [0x20ac, 0x20ac],\n    [0x2122, 0x2122],\n  ],\n  // Everything in `latin` plus Latin Extended-A/B (Central/Eastern-European: ą ž ł ő …).\n  'latin-ext': [\n    [0x20, 0x7e],\n    [0xa0, 0xff],\n    [0x100, 0x24f],\n    [0x2010, 0x2014],\n    [0x2018, 0x201f],\n    [0x2022, 0x2022],\n    [0x2026, 0x2026],\n    [0x20ac, 0x20ac],\n    [0x2122, 0x2122],\n  ],\n}\n\n/** The subsetter charset: a built-in preset name, or an explicit string of characters to keep. */\nexport type Charset = 'latin' | 'latin-ext' | (string & {})\n\nconst rangesToText = (ranges: Array<[number, number]>): string => {\n  let text = ''\n  for (const [start, end] of ranges) for (let cp = start; cp <= end; cp++) text += String.fromCodePoint(cp)\n  return text\n}\n\n/**\n * Resolve a charset option to the set of characters the subsetter should keep. A known\n * preset name ('latin' | 'latin-ext') expands to its ranges; any other string is treated\n * as an explicit, verbatim list of characters to retain.\n */\nexport const resolveCharsetText = (charset: Charset = 'latin'): string => {\n  const preset = CHARSET_PRESETS[charset]\n  return preset ? rangesToText(preset) : charset\n}\n\n/** The slice of fontkit's `Font` we read for weight/style/family detection. */\ntype FontkitFont = {\n  familyName?: string | null\n  subfamilyName?: string | null\n  italicAngle?: number\n  /** Variation axes by tag (variable fonts only); we read `wght` for the weight range. */\n  variationAxes?: Record<string, { min: number; default: number; max: number }> | null\n  'OS/2'?: { usWeightClass?: number; fsSelection?: number } | null\n}\n\n/** subset-font's default export: subset + convert in one call. */\ntype SubsetFontFn = (buffer: Buffer, text: string, options: { targetFormat: 'woff2' | 'woff' | 'sfnt' }) => Promise<Buffer>\n\n/** Clamp an arbitrary OS/2 weight class to the nearest standard 100–900 step. */\nconst normalizeWeight = (weight?: number): string | undefined => {\n  if (!weight || Number.isNaN(weight)) return undefined\n  return String(Math.min(900, Math.max(100, Math.round(weight / 100) * 100)))\n}\n\n/** What {@link detectMetadata} reads out of a font binary. */\nexport interface FontFileMetadata {\n  familyName?: string\n  weight?: string\n  style?: 'normal' | 'italic'\n  isVariable: boolean\n  /** The file ALSO carries italics through a variation axis (an `ital` axis reaching 1, or a\n   *  negative `slnt` range) while its default instance is upright — one file, both styles. */\n  italCapable?: boolean\n  /** For `slnt`-based italics: the positive CSS oblique angle (deg) matching the axis extreme. */\n  obliqueAngle?: number\n}\n\n/**\n * Best-effort read of weight / style / family from a font's metadata via the bundled\n * `fontkit` dependency. Returns `null` when the font can't be parsed.\n *\n * A `wght` variation axis marks a variable font: we keep its full `min max` range (e.g.\n * `'100 900'`) — exactly what `next/font/local` expects — instead of clamping to the\n * single default-instance weight class as we do for static fonts.\n *\n * An upright variable file whose axes ALSO cover italics — a true `ital` axis reaching 1, or a\n * `slnt` axis leaning forward (negative min) — is flagged `italCapable`, so the serving layers\n * can emit an italic `@font-face` from the same file (CSS maps `font-style: italic` onto `ital`\n * and `font-style: oblique <angle>` onto `slnt`).\n */\nexport async function detectMetadata(buffer: Buffer): Promise<FontFileMetadata | null> {\n  try {\n    // fontkit v2 ships `create` as a NAMED export under node's ESM interop (no usable\n    // `default`), but bundlers may synthesize a default — accept either, or detection\n    // silently no-ops and weight/style/family never autofill.\n    const mod = (await import('fontkit')) as unknown as { create?: (b: Buffer) => unknown; default?: { create?: (b: Buffer) => unknown } }\n    const create = mod.create ?? mod.default?.create\n    if (!create) return null\n    const font = create(buffer) as FontkitFont\n    const italic = Boolean(\n      (typeof font.italicAngle === 'number' && font.italicAngle !== 0) ||\n        (font['OS/2']?.fsSelection ?? 0) & 0x01 ||\n        /italic|oblique/i.test(font.subfamilyName ?? ''),\n    )\n    const wght = font.variationAxes?.wght\n    const weight = wght ? `${Math.round(wght.min)} ${Math.round(wght.max)}` : normalizeWeight(font['OS/2']?.usWeightClass)\n\n    let italCapable: boolean | undefined\n    let obliqueAngle: number | undefined\n    if (!italic) {\n      const ital = font.variationAxes?.ital\n      const slnt = font.variationAxes?.slnt\n      if (ital && ital.max >= 1) italCapable = true\n      else if (slnt && slnt.min < 0) {\n        italCapable = true\n        obliqueAngle = Math.round(Math.abs(slnt.min))\n      }\n    }\n\n    return {\n      familyName: font.familyName ?? undefined,\n      weight,\n      style: italic ? 'italic' : 'normal',\n      isVariable: Boolean(wght),\n      ...(italCapable ? { italCapable } : {}),\n      ...(obliqueAngle ? { obliqueAngle } : {}),\n    }\n  } catch {\n    return null\n  }\n}\n\n/**\n * Subset a font buffer to a WOFF2 using the bundled `subset-font` (harfbuzz). Variable\n * axes are preserved (harfbuzz keeps `fvar`/`gvar` unless axes are explicitly pinned), so\n * a variable font stays variable through the subset.\n */\nexport async function subsetToWoff2(buffer: Buffer, charsetText: string): Promise<Buffer> {\n  const subsetFont = (await import('subset-font')).default as unknown as SubsetFontFn\n  return subsetFont(buffer, charsetText, { targetFormat: 'woff2' })\n}\n\n/**\n * The most common deployment mistake: a bundler (Next/Turbopack) bundles the harfbuzz / fontkit\n * wasm + native assets, rewriting their load paths to virtual ones that don't exist on disk. The\n * subset then throws at runtime, fonts upload but never get subsetted, and nothing is served.\n * True when an error is that load failure (vs. an ordinary bad-font error).\n */\nexport const isSubsetterLoadError = (err: unknown): boolean => {\n  const msg = err instanceof Error ? `${err.message}\\n${err.stack ?? ''}` : String(err)\n  return (\n    /(hb-subset\\.wasm|harfbuzzjs|subset-font|fontkit)/i.test(msg) &&\n    /(ENOENT|no such file|cannot find module|failed to load|MODULE_NOT_FOUND)/i.test(msg)\n  )\n}\n\n/**\n * Boot-time probe for that mistake. Importing `subset-font` is NOT enough to detect it — harfbuzz\n * reads its wasm lazily (`_.once`) on the FIRST SUBSET CALL — so this runs a real subset on a\n * garbage buffer: the wasm loads (and fails loudly if bundled) before the buffer is ever parsed.\n * Resolves `null` when the subsetter is healthy — a bad-font error from the garbage buffer proves\n * the wasm loaded — or the load error for the caller to report.\n */\nexport async function probeSubsetter(): Promise<unknown | null> {\n  try {\n    await subsetToWoff2(Buffer.from('not a font'), 'a')\n  } catch (err) {\n    if (isSubsetterLoadError(err)) return err\n  }\n  return null\n}\n"],"names":["CHARSET_PRESETS","latin","rangesToText","ranges","text","start","end","cp","String","fromCodePoint","resolveCharsetText","charset","preset","normalizeWeight","weight","Number","isNaN","undefined","Math","min","max","round","detectMetadata","buffer","mod","create","default","font","italic","Boolean","italicAngle","fsSelection","test","subfamilyName","wght","variationAxes","usWeightClass","italCapable","obliqueAngle","ital","slnt","abs","familyName","style","isVariable","subsetToWoff2","charsetText","subsetFont","targetFormat","isSubsetterLoadError","err","msg","Error","message","stack","probeSubsetter","Buffer","from"],"mappings":"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"}

package/dist/hooks/optimizeFromOriginals.d.ts

@@ -0,0 +1,43 @@
+import type { CollectionAfterChangeHook, CollectionBeforeDeleteHook } from 'payload';
+import { type Charset } from './optimizeFont';
+/**
+ * Every `fontOriginal` id a typeface doc references across all of its slots. Each original
+ * belongs to exactly one typeface — enforced by the create-only upload slots (UI) and the
+ * `rejectSharedOriginals` guard (data layer) — so cleanup can delete a de-referenced or
+ * deleted original outright, with no shared-original / concurrent-delete hazard.
+ */
+export declare const originalIdsFromDoc: (data: Record<string, unknown>) => Array<string | number>;
+export interface OptimizeFromOriginalsOptions {
+    /** Characters to keep, or a preset name ('latin' | 'latin-ext'). Default 'latin'. */
+    charset?: Charset;
+    /** Slug of the archival original collection. Default 'fontOriginal'. */
+    originalSlug?: string;
+    /** Slug of the optimized (served) collection. Default 'fontOptimized'. */
+    optimizedSlug?: string;
+}
+/**
+ * `afterChange` for the `Font` typeface: reconcile its served `fontOptimized` files
+ * against the `fontOriginal` files referenced in its slots.
+ *
+ * Keyed by source-original id: a newly-referenced original is fetched, subsetted to WOFF2
+ * (variable weight range read from the `wght` axis; static weight/style from the row) and
+ * created; an original that's gone has its optimized deleted; an unchanged original is kept
+ * (only its weight/style metadata is synced if the row changed). Best-effort — a single bad
+ * font logs a warning and is skipped, never failing the typeface save. Touches only
+ * `fontOptimized`, so it can't re-trigger this hook.
+ */
+export declare const optimizeFromOriginalsHook: (opts?: OptimizeFromOriginalsOptions) => CollectionAfterChangeHook;
+/**
+ * `beforeDelete` for the `Font` typeface: cascade-delete its served `fontOptimized` files and
+ * the `fontOriginal` files its slots referenced, so nothing orphans in storage. Best-effort.
+ *
+ * It runs `beforeDelete` (not after) on purpose: deleting the `font` doc triggers Payload's
+ * dangling-reference cleanup, which nulls `fontOptimized.font` — so by `afterDelete` the served
+ * files can no longer be found by their owning typeface. Here the relationship is still intact,
+ * so we resolve them by `font` first (and read the originals off the doc's own upload slots).
+ */
+export declare const cleanupFontAssetsHook: (opts?: {
+    originalSlug?: string;
+    optimizedSlug?: string;
+}) => CollectionBeforeDeleteHook;
+//# sourceMappingURL=optimizeFromOriginals.d.ts.map

package/dist/hooks/optimizeFromOriginals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizeFromOriginals.d.ts","sourceRoot":"","sources":["../../src/hooks/optimizeFromOriginals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,0BAA0B,EAAkB,MAAM,SAAS,CAAA;AAIpG,OAAO,EAAE,KAAK,OAAO,EAA2E,MAAM,gBAAgB,CAAA;AAatH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAYvF,CAAA;AAgCD,MAAM,WAAW,4BAA4B;IAC3C,qFAAqF;IACrF,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,wEAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAM,4BAAiC,KAAG,yBAoInF,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAM;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,KAAG,0BA+CpG,CAAA"}