@pro-laico/payload-fonts 0.0.0

package/dist/hooks/optimizeFromOriginals.js

@@ -0,0 +1,313 @@
+import { refId } from "../lib/refs.js";
+import { readUploadBytes } from "../lib/uploadBytes.js";
+import { detectMetadata, isSubsetterLoadError, resolveCharsetText, subsetToWoff2 } from "./optimizeFont.js";
+/** True when a delete failed because the doc is already gone — the goal state, not a problem.
+ *  Happens routinely when another path deleted it first (e.g. a seed run clears `fontOriginal`
+ *  directly, then clearing `font` fires this cascade at the same ids). */ const isNotFound = (err)=>err?.status === 404 || err instanceof Error && err.name === 'NotFound';
+// Surface the bundled-subsetter load failure (see isSubsetterLoadError) as ONE loud, actionable
+// log instead of only the generic per-font warning.
+let warnedSubsetterLoad = false;
+/**
+ * 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 const originalIdsFromDoc = (data)=>{
+    const ids = [];
+    const variable = data.variable ?? {};
+    for (const r of [
+        variable.upright,
+        variable.italic
+    ]){
+        const id = refId(r);
+        if (id != null) ids.push(id);
+    }
+    for (const row of Array.isArray(data.weights) ? data.weights : []){
+        const id = refId(row.file);
+        if (id != null) ids.push(id);
+    }
+    return ids;
+};
+/** Read the font doc's slots into the set of originals to optimize. */ const desiredFromDoc = (data)=>{
+    const desired = [];
+    const variable = data.variable ?? {};
+    const uprightId = refId(variable.upright);
+    const italicId = refId(variable.italic);
+    if (uprightId != null) desired.push({
+        originalId: uprightId,
+        style: 'normal',
+        isVariable: true
+    });
+    if (italicId != null) desired.push({
+        originalId: italicId,
+        style: 'italic',
+        isVariable: true
+    });
+    // Variable and weights are mutually exclusive (enforced on the collection); only read the
+    // weights array when no variable file is present.
+    if (uprightId == null && italicId == null) {
+        const weights = Array.isArray(data.weights) ? data.weights : [];
+        for (const row of weights){
+            const fid = refId(row.file);
+            if (fid != null) desired.push({
+                originalId: fid,
+                style: row.style === 'italic' ? 'italic' : 'normal',
+                isVariable: false,
+                weight: row.weight
+            });
+        }
+    }
+    return desired;
+};
+/**
+ * `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 const optimizeFromOriginalsHook = (opts = {})=>{
+    const charsetText = resolveCharsetText(opts.charset);
+    const originalSlug = opts.originalSlug || 'fontOriginal';
+    const optimizedSlug = opts.optimizedSlug || 'fontOptimized';
+    return async ({ doc, operation, previousDoc, req })=>{
+        const data = doc;
+        const fontId = data.id;
+        const desired = desiredFromDoc(data);
+        // Forward the request's auth so reading the original succeeds when it lives on cloud
+        // storage served through Payload's own access-controlled file route — an unauthenticated
+        // fetch 403s. `origin`/`referer` are required too: Payload's CSRF protection rejects a
+        // cookie-authenticated request whose Origin isn't allow-listed.
+        const fwdHeaders = {};
+        for (const h of [
+            'cookie',
+            'authorization',
+            'origin',
+            'referer'
+        ]){
+            const v = req.headers?.get(h);
+            if (v) fwdHeaders[h] = v;
+        }
+        try {
+            const existing = await req.payload.find({
+                collection: optimizedSlug,
+                where: {
+                    font: {
+                        equals: fontId
+                    }
+                },
+                depth: 0,
+                limit: 1000,
+                overrideAccess: true,
+                req
+            });
+            const byOriginal = new Map();
+            for (const d of existing.docs){
+                const oid = refId(d.original);
+                if (oid != null) byOriginal.set(oid, d);
+            }
+            const desiredIds = new Set(desired.map((d)=>d.originalId));
+            // Create new, or sync metadata on a kept one whose row changed.
+            for (const d of desired){
+                const current = byOriginal.get(d.originalId);
+                if (current) {
+                    const weightDrift = !d.isVariable && d.weight && String(current.weight ?? '') !== d.weight;
+                    if (weightDrift || String(current.style ?? '') !== d.style) {
+                        await req.payload.update({
+                            collection: optimizedSlug,
+                            id: current.id,
+                            data: {
+                                weight: d.weight ?? current.weight,
+                                style: d.style
+                            },
+                            overrideAccess: true,
+                            req
+                        });
+                    }
+                    continue;
+                }
+                try {
+                    const original = await req.payload.findByID({
+                        collection: originalSlug,
+                        id: d.originalId,
+                        depth: 0,
+                        overrideAccess: true,
+                        req
+                    });
+                    const bytes = await readUploadBytes(req.payload, originalSlug, original, {
+                        headers: fwdHeaders
+                    });
+                    if (!bytes) {
+                        req.payload.logger.warn(`Font optimize: could not read original ${d.originalId}`);
+                        continue;
+                    }
+                    const meta = await detectMetadata(bytes);
+                    const woff2 = await subsetToWoff2(bytes, charsetText);
+                    // Variable: the intrinsic axis range wins. Static: the row's weight wins, detection fills a blank.
+                    const weight = d.isVariable ? meta?.weight ?? d.weight : d.weight ?? meta?.weight;
+                    // An upright variable file whose axes also cover italics (ital / negative slnt) is
+                    // flagged so the serving layers can emit an italic face from the same file.
+                    const italCapable = Boolean(d.style === 'normal' && meta?.italCapable);
+                    const baseName = (original.filename || `font-${d.originalId}`).replace(/\.[^.]+$/, '');
+                    // Shallow-cloned req: createLocalReq mutates `.file` on the req it's given; the clone
+                    // keeps that off the parent while sharing the transaction.
+                    await req.payload.create({
+                        collection: optimizedSlug,
+                        req: {
+                            ...req
+                        },
+                        overrideAccess: true,
+                        data: {
+                            font: fontId,
+                            original: d.originalId,
+                            weight,
+                            style: d.style,
+                            isVariable: meta?.isVariable ?? d.isVariable,
+                            italCapable,
+                            ...italCapable && meta?.obliqueAngle ? {
+                                obliqueAngle: meta.obliqueAngle
+                            } : {}
+                        },
+                        file: {
+                            data: woff2,
+                            name: `${baseName}.woff2`,
+                            mimetype: 'font/woff2',
+                            size: woff2.length
+                        }
+                    });
+                } catch (err) {
+                    if (isSubsetterLoadError(err) && !warnedSubsetterLoad) {
+                        warnedSubsetterLoad = true;
+                        req.payload.logger.error("[payload-fonts] The font subsetter failed to LOAD (subset-font / harfbuzz wasm / fontkit) — uploaded fonts are NOT being subsetted, so no web fonts will be served. In Next.js the wasm/native deps were bundled: add `serverExternalPackages: ['subset-font', 'harfbuzzjs', 'fontkit']` to your next.config. Docs: https://payload-plugins.prolaico.com/docs/plugins/payload-fonts");
+                    }
+                    req.payload.logger.warn({
+                        msg: `Font optimization failed for original ${d.originalId}`,
+                        err
+                    });
+                }
+            }
+            // Delete optimized files whose source original is no longer referenced.
+            for (const [oid, d] of byOriginal){
+                if (desiredIds.has(oid)) continue;
+                try {
+                    await req.payload.delete({
+                        collection: optimizedSlug,
+                        id: d.id,
+                        overrideAccess: true,
+                        req
+                    });
+                } catch (err) {
+                    if (!isNotFound(err)) req.payload.logger.warn({
+                        msg: 'Could not delete stale optimized font',
+                        err
+                    });
+                }
+            }
+            // Delete originals this update de-referenced (a swapped/removed slot file). Originals
+            // aren't shared (create-only slots), so this is always safe.
+            if (operation === 'update' && previousDoc) {
+                const stillReferenced = new Set(originalIdsFromDoc(data));
+                for (const oid of originalIdsFromDoc(previousDoc)){
+                    if (stillReferenced.has(oid)) continue;
+                    try {
+                        await req.payload.delete({
+                            collection: originalSlug,
+                            id: oid,
+                            overrideAccess: true,
+                            req
+                        });
+                    } catch (err) {
+                        if (!isNotFound(err)) req.payload.logger.warn({
+                            msg: `Could not delete de-referenced font original ${oid}`,
+                            err
+                        });
+                    }
+                }
+            }
+        } catch (err) {
+            req.payload.logger.warn({
+                msg: 'Font optimize reconcile failed',
+                err
+            });
+        }
+        return doc;
+    };
+};
+/**
+ * `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 const cleanupFontAssetsHook = (opts = {})=>{
+    const originalSlug = opts.originalSlug || 'fontOriginal';
+    const optimizedSlug = opts.optimizedSlug || 'fontOptimized';
+    return async ({ collection, id, req })=>{
+        // Load the doc so we can read its `fontOriginal` slot ids (the font's own upload fields).
+        let data;
+        try {
+            data = await req.payload.findByID({
+                collection: collection.slug,
+                id,
+                depth: 0,
+                overrideAccess: true,
+                req
+            });
+        } catch  {
+        // gone already / not found — fall through, optimized cleanup below still runs by `font`
+        }
+        // Delete the served files, found by owning typeface while the relationship still exists.
+        try {
+            const optimized = await req.payload.find({
+                collection: optimizedSlug,
+                where: {
+                    font: {
+                        equals: id
+                    }
+                },
+                depth: 0,
+                limit: 1000,
+                overrideAccess: true,
+                req
+            });
+            for (const d of optimized.docs){
+                await req.payload.delete({
+                    collection: optimizedSlug,
+                    id: d.id,
+                    overrideAccess: true,
+                    req
+                });
+            }
+        } catch (err) {
+            req.payload.logger.warn({
+                msg: 'Could not delete optimized fonts',
+                err
+            });
+        }
+        // Delete the originals this typeface referenced (create-only slots → never shared).
+        if (data) {
+            for (const oid of originalIdsFromDoc(data)){
+                try {
+                    await req.payload.delete({
+                        collection: originalSlug,
+                        id: oid,
+                        overrideAccess: true,
+                        req
+                    });
+                } catch (err) {
+                    if (!isNotFound(err)) req.payload.logger.warn({
+                        msg: 'Could not delete font original',
+                        err
+                    });
+                }
+            }
+        }
+    };
+};
+
+//# sourceMappingURL=optimizeFromOriginals.js.map

package/dist/hooks/optimizeFromOriginals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/optimizeFromOriginals.ts"],"sourcesContent":["import type { CollectionAfterChangeHook, CollectionBeforeDeleteHook, CollectionSlug } from 'payload'\n\nimport { refId } from '../lib/refs'\nimport { readUploadBytes } from '../lib/uploadBytes'\nimport { type Charset, detectMetadata, isSubsetterLoadError, resolveCharsetText, subsetToWoff2 } from './optimizeFont'\n\ntype Ref = string | number | { id?: string | number } | null | undefined\n\n/** True when a delete failed because the doc is already gone — the goal state, not a problem.\n *  Happens routinely when another path deleted it first (e.g. a seed run clears `fontOriginal`\n *  directly, then clearing `font` fires this cascade at the same ids). */\nconst isNotFound = (err: unknown): boolean => (err as { status?: number })?.status === 404 || (err instanceof Error && err.name === 'NotFound')\n\n// Surface the bundled-subsetter load failure (see isSubsetterLoadError) as ONE loud, actionable\n// log instead of only the generic per-font warning.\nlet warnedSubsetterLoad = false\n\n/**\n * Every `fontOriginal` id a typeface doc references across all of its slots. Each original\n * belongs to exactly one typeface — enforced by the create-only upload slots (UI) and the\n * `rejectSharedOriginals` guard (data layer) — so cleanup can delete a de-referenced or\n * deleted original outright, with no shared-original / concurrent-delete hazard.\n */\nexport const originalIdsFromDoc = (data: Record<string, unknown>): Array<string | number> => {\n  const ids: Array<string | number> = []\n  const variable = (data.variable ?? {}) as { upright?: Ref; italic?: Ref }\n  for (const r of [variable.upright, variable.italic]) {\n    const id = refId(r)\n    if (id != null) ids.push(id)\n  }\n  for (const row of (Array.isArray(data.weights) ? data.weights : []) as Array<{ file?: Ref }>) {\n    const id = refId(row.file)\n    if (id != null) ids.push(id)\n  }\n  return ids\n}\n\n/** A weight/style file the typeface should have an optimized WOFF2 for. */\ninterface Desired {\n  originalId: string | number\n  style: 'normal' | 'italic'\n  isVariable: boolean\n  /** Static rows carry an explicit weight; variable files derive a range from the binary. */\n  weight?: string\n}\n\n/** Read the font doc's slots into the set of originals to optimize. */\nconst desiredFromDoc = (data: Record<string, unknown>): Desired[] => {\n  const desired: Desired[] = []\n  const variable = (data.variable ?? {}) as { upright?: Ref; italic?: Ref }\n  const uprightId = refId(variable.upright)\n  const italicId = refId(variable.italic)\n  if (uprightId != null) desired.push({ originalId: uprightId, style: 'normal', isVariable: true })\n  if (italicId != null) desired.push({ originalId: italicId, style: 'italic', isVariable: true })\n  // Variable and weights are mutually exclusive (enforced on the collection); only read the\n  // weights array when no variable file is present.\n  if (uprightId == null && italicId == null) {\n    const weights = Array.isArray(data.weights) ? data.weights : []\n    for (const row of weights as Array<{ weight?: string; style?: string; file?: Ref }>) {\n      const fid = refId(row.file)\n      if (fid != null)\n        desired.push({ originalId: fid, style: row.style === 'italic' ? 'italic' : 'normal', isVariable: false, weight: row.weight })\n    }\n  }\n  return desired\n}\n\nexport interface OptimizeFromOriginalsOptions {\n  /** Characters to keep, or a preset name ('latin' | 'latin-ext'). Default 'latin'. */\n  charset?: Charset\n  /** Slug of the archival original collection. Default 'fontOriginal'. */\n  originalSlug?: string\n  /** Slug of the optimized (served) collection. Default 'fontOptimized'. */\n  optimizedSlug?: string\n}\n\n/**\n * `afterChange` for the `Font` typeface: reconcile its served `fontOptimized` files\n * against the `fontOriginal` files referenced in its slots.\n *\n * Keyed by source-original id: a newly-referenced original is fetched, subsetted to WOFF2\n * (variable weight range read from the `wght` axis; static weight/style from the row) and\n * created; an original that's gone has its optimized deleted; an unchanged original is kept\n * (only its weight/style metadata is synced if the row changed). Best-effort — a single bad\n * font logs a warning and is skipped, never failing the typeface save. Touches only\n * `fontOptimized`, so it can't re-trigger this hook.\n */\nexport const optimizeFromOriginalsHook = (opts: OptimizeFromOriginalsOptions = {}): CollectionAfterChangeHook => {\n  const charsetText = resolveCharsetText(opts.charset)\n  const originalSlug = (opts.originalSlug || 'fontOriginal') as CollectionSlug\n  const optimizedSlug = (opts.optimizedSlug || 'fontOptimized') as CollectionSlug\n\n  return async ({ doc, operation, previousDoc, req }) => {\n    const data = doc as Record<string, unknown>\n    const fontId = data.id as string | number\n    const desired = desiredFromDoc(data)\n\n    // Forward the request's auth so reading the original succeeds when it lives on cloud\n    // storage served through Payload's own access-controlled file route — an unauthenticated\n    // fetch 403s. `origin`/`referer` are required too: Payload's CSRF protection rejects a\n    // cookie-authenticated request whose Origin isn't allow-listed.\n    const fwdHeaders: Record<string, string> = {}\n    for (const h of ['cookie', 'authorization', 'origin', 'referer']) {\n      const v = req.headers?.get(h)\n      if (v) fwdHeaders[h] = v\n    }\n\n    try {\n      const existing = await req.payload.find({\n        collection: optimizedSlug,\n        where: { font: { equals: fontId } },\n        depth: 0,\n        limit: 1000,\n        overrideAccess: true,\n        req,\n      })\n      const byOriginal = new Map<string | number, Record<string, unknown>>()\n      for (const d of existing.docs as unknown as Array<Record<string, unknown>>) {\n        const oid = refId(d.original as Ref)\n        if (oid != null) byOriginal.set(oid, d)\n      }\n      const desiredIds = new Set(desired.map((d) => d.originalId))\n\n      // Create new, or sync metadata on a kept one whose row changed.\n      for (const d of desired) {\n        const current = byOriginal.get(d.originalId)\n        if (current) {\n          const weightDrift = !d.isVariable && d.weight && String(current.weight ?? '') !== d.weight\n          if (weightDrift || String(current.style ?? '') !== d.style) {\n            await req.payload.update({\n              collection: optimizedSlug,\n              id: current.id as string | number,\n              data: { weight: d.weight ?? current.weight, style: d.style } as never,\n              overrideAccess: true,\n              req,\n            })\n          }\n          continue\n        }\n        try {\n          const original = (await req.payload.findByID({\n            collection: originalSlug,\n            id: d.originalId,\n            depth: 0,\n            overrideAccess: true,\n            req,\n          })) as {\n            filename?: string | null\n            url?: string | null\n          }\n          const bytes = await readUploadBytes(req.payload, originalSlug, original, { headers: fwdHeaders })\n          if (!bytes) {\n            req.payload.logger.warn(`Font optimize: could not read original ${d.originalId}`)\n            continue\n          }\n          const meta = await detectMetadata(bytes)\n          const woff2 = await subsetToWoff2(bytes, charsetText)\n          // Variable: the intrinsic axis range wins. Static: the row's weight wins, detection fills a blank.\n          const weight = d.isVariable ? (meta?.weight ?? d.weight) : (d.weight ?? meta?.weight)\n          // An upright variable file whose axes also cover italics (ital / negative slnt) is\n          // flagged so the serving layers can emit an italic face from the same file.\n          const italCapable = Boolean(d.style === 'normal' && meta?.italCapable)\n          const baseName = (original.filename || `font-${d.originalId}`).replace(/\\.[^.]+$/, '')\n          // Shallow-cloned req: createLocalReq mutates `.file` on the req it's given; the clone\n          // keeps that off the parent while sharing the transaction.\n          await req.payload.create({\n            collection: optimizedSlug,\n            req: { ...req },\n            overrideAccess: true,\n            data: {\n              font: fontId,\n              original: d.originalId,\n              weight,\n              style: d.style,\n              isVariable: meta?.isVariable ?? d.isVariable,\n              italCapable,\n              ...(italCapable && meta?.obliqueAngle ? { obliqueAngle: meta.obliqueAngle } : {}),\n            } as never,\n            file: { data: woff2, name: `${baseName}.woff2`, mimetype: 'font/woff2', size: woff2.length },\n          })\n        } catch (err) {\n          if (isSubsetterLoadError(err) && !warnedSubsetterLoad) {\n            warnedSubsetterLoad = true\n            req.payload.logger.error(\n              \"[payload-fonts] The font subsetter failed to LOAD (subset-font / harfbuzz wasm / fontkit) — uploaded fonts are NOT being subsetted, so no web fonts will be served. In Next.js the wasm/native deps were bundled: add `serverExternalPackages: ['subset-font', 'harfbuzzjs', 'fontkit']` to your next.config. Docs: https://payload-plugins.prolaico.com/docs/plugins/payload-fonts\",\n            )\n          }\n          req.payload.logger.warn({ msg: `Font optimization failed for original ${d.originalId}`, err })\n        }\n      }\n\n      // Delete optimized files whose source original is no longer referenced.\n      for (const [oid, d] of byOriginal) {\n        if (desiredIds.has(oid)) continue\n        try {\n          await req.payload.delete({ collection: optimizedSlug, id: d.id as string | number, overrideAccess: true, req })\n        } catch (err) {\n          if (!isNotFound(err)) req.payload.logger.warn({ msg: 'Could not delete stale optimized font', err })\n        }\n      }\n\n      // Delete originals this update de-referenced (a swapped/removed slot file). Originals\n      // aren't shared (create-only slots), so this is always safe.\n      if (operation === 'update' && previousDoc) {\n        const stillReferenced = new Set(originalIdsFromDoc(data))\n        for (const oid of originalIdsFromDoc(previousDoc as Record<string, unknown>)) {\n          if (stillReferenced.has(oid)) continue\n          try {\n            await req.payload.delete({ collection: originalSlug, id: oid, overrideAccess: true, req })\n          } catch (err) {\n            if (!isNotFound(err)) req.payload.logger.warn({ msg: `Could not delete de-referenced font original ${oid}`, err })\n          }\n        }\n      }\n    } catch (err) {\n      req.payload.logger.warn({ msg: 'Font optimize reconcile failed', err })\n    }\n    return doc\n  }\n}\n\n/**\n * `beforeDelete` for the `Font` typeface: cascade-delete its served `fontOptimized` files and\n * the `fontOriginal` files its slots referenced, so nothing orphans in storage. Best-effort.\n *\n * It runs `beforeDelete` (not after) on purpose: deleting the `font` doc triggers Payload's\n * dangling-reference cleanup, which nulls `fontOptimized.font` — so by `afterDelete` the served\n * files can no longer be found by their owning typeface. Here the relationship is still intact,\n * so we resolve them by `font` first (and read the originals off the doc's own upload slots).\n */\nexport const cleanupFontAssetsHook = (opts: { originalSlug?: string; optimizedSlug?: string } = {}): CollectionBeforeDeleteHook => {\n  const originalSlug = (opts.originalSlug || 'fontOriginal') as CollectionSlug\n  const optimizedSlug = (opts.optimizedSlug || 'fontOptimized') as CollectionSlug\n\n  return async ({ collection, id, req }) => {\n    // Load the doc so we can read its `fontOriginal` slot ids (the font's own upload fields).\n    let data: Record<string, unknown> | undefined\n    try {\n      data = (await req.payload.findByID({\n        collection: collection.slug as CollectionSlug,\n        id,\n        depth: 0,\n        overrideAccess: true,\n        req,\n      })) as unknown as Record<string, unknown>\n    } catch {\n      // gone already / not found — fall through, optimized cleanup below still runs by `font`\n    }\n\n    // Delete the served files, found by owning typeface while the relationship still exists.\n    try {\n      const optimized = await req.payload.find({\n        collection: optimizedSlug,\n        where: { font: { equals: id } },\n        depth: 0,\n        limit: 1000,\n        overrideAccess: true,\n        req,\n      })\n      for (const d of optimized.docs as Array<{ id: string | number }>) {\n        await req.payload.delete({ collection: optimizedSlug, id: d.id, overrideAccess: true, req })\n      }\n    } catch (err) {\n      req.payload.logger.warn({ msg: 'Could not delete optimized fonts', err })\n    }\n\n    // Delete the originals this typeface referenced (create-only slots → never shared).\n    if (data) {\n      for (const oid of originalIdsFromDoc(data)) {\n        try {\n          await req.payload.delete({ collection: originalSlug, id: oid, overrideAccess: true, req })\n        } catch (err) {\n          if (!isNotFound(err)) req.payload.logger.warn({ msg: 'Could not delete font original', err })\n        }\n      }\n    }\n  }\n}\n"],"names":["refId","readUploadBytes","detectMetadata","isSubsetterLoadError","resolveCharsetText","subsetToWoff2","isNotFound","err","status","Error","name","warnedSubsetterLoad","originalIdsFromDoc","data","ids","variable","r","upright","italic","id","push","row","Array","isArray","weights","file","desiredFromDoc","desired","uprightId","italicId","originalId","style","isVariable","fid","weight","optimizeFromOriginalsHook","opts","charsetText","charset","originalSlug","optimizedSlug","doc","operation","previousDoc","req","fontId","fwdHeaders","h","v","headers","get","existing","payload","find","collection","where","font","equals","depth","limit","overrideAccess","byOriginal","Map","d","docs","oid","original","set","desiredIds","Set","map","current","weightDrift","String","update","findByID","bytes","logger","warn","meta","woff2","italCapable","Boolean","baseName","filename","replace","create","obliqueAngle","mimetype","size","length","error","msg","has","delete","stillReferenced","cleanupFontAssetsHook","slug","optimized"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { default, fontsPlugin } from './plugin';
+export { DEFAULT_FONT_FAMILIES } from './lib/families';
+export type { FontFamilyConfig } from './lib/families';
+export { extractFonts } from './extractFonts';
+export { buildFontFaceCss, getActiveFontFaces } from './lib/activeFonts';
+export type { ActiveFace, ActiveTypeface } from './lib/activeFonts';
+export type { ExportFamilyDiagnostics, ExportFontsResponse } from './endpoints/exportFonts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAI/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAOtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACxE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAGnE,YAAY,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// The plugin
+export { default, fontsPlugin } from "./plugin.js";
+// Font families (slots). `FontFamilyConfig` is the `{ key, label?, fallback? }` shape you pass to
+// `fontsPlugin({ families })`; spread `DEFAULT_FONT_FAMILIES` to extend the built-in set.
+export { DEFAULT_FONT_FAMILIES } from "./lib/families.js";
+// Frontend serving. The dev-only runtime component lives at the `@pro-laico/payload-fonts/DevFonts`
+// subpath; `extractFonts` collects the generated next/font/local classes for `<html>`;
+// `getActiveFontFaces` resolves the active `fontSet` selection to its served files (the read behind
+// DevFonts, for custom UIs that list or serve the active fonts) and `buildFontFaceCss` turns them
+// into `@font-face` rules + family variables. `ActiveTypeface`/`ActiveFace` are their shared shape.
+export { extractFonts } from "./extractFonts.js";
+export { buildFontFaceCss, getActiveFontFaces } from "./lib/activeFonts.js";
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// The plugin\nexport { default, fontsPlugin } from './plugin'\n\n// Font families (slots). `FontFamilyConfig` is the `{ key, label?, fallback? }` shape you pass to\n// `fontsPlugin({ families })`; spread `DEFAULT_FONT_FAMILIES` to extend the built-in set.\nexport { DEFAULT_FONT_FAMILIES } from './lib/families'\nexport type { FontFamilyConfig } from './lib/families'\n\n// Frontend serving. The dev-only runtime component lives at the `@pro-laico/payload-fonts/DevFonts`\n// subpath; `extractFonts` collects the generated next/font/local classes for `<html>`;\n// `getActiveFontFaces` resolves the active `fontSet` selection to its served files (the read behind\n// DevFonts, for custom UIs that list or serve the active fonts) and `buildFontFaceCss` turns them\n// into `@font-face` rules + family variables. `ActiveTypeface`/`ActiveFace` are their shared shape.\nexport { extractFonts } from './extractFonts'\nexport { buildFontFaceCss, getActiveFontFaces } from './lib/activeFonts'\nexport type { ActiveFace, ActiveTypeface } from './lib/activeFonts'\n\n// Response shape of `GET /api/fonts/export` — for custom consumers of the endpoint.\nexport type { ExportFamilyDiagnostics, ExportFontsResponse } from './endpoints/exportFonts'\n"],"names":["default","fontsPlugin","DEFAULT_FONT_FAMILIES","extractFonts","buildFontFaceCss","getActiveFontFaces"],"mappings":"AAAA,aAAa;AACb,SAASA,OAAO,EAAEC,WAAW,QAAQ,cAAU;AAE/C,kGAAkG;AAClG,0FAA0F;AAC1F,SAASC,qBAAqB,QAAQ,oBAAgB;AAGtD,oGAAoG;AACpG,uFAAuF;AACvF,oGAAoG;AACpG,kGAAkG;AAClG,oGAAoG;AACpG,SAASC,YAAY,QAAQ,oBAAgB;AAC7C,SAASC,gBAAgB,EAAEC,kBAAkB,QAAQ,uBAAmB"}

package/dist/lib/activeFonts.d.ts

@@ -0,0 +1,64 @@
+import type { Payload } from 'payload';
+/** A family key. `sans`/`serif`/`mono`/`display` by default, but any string when customised. */
+export type FontFamily = string;
+/** One served face. Usually one per `fontOptimized` doc — but an upright variable file whose
+ *  axes also cover italics (`italCapable`) expands into a second, italic face over the SAME file. */
+export interface ActiveFace {
+    filename: string;
+    /** A single CSS weight ('400') or a variable range ('100 900'). */
+    weight: string;
+    style: 'normal' | 'italic';
+    /** For slnt-based italics: the positive CSS `oblique` angle (deg). Absent = a true italic
+     *  (explicit file, or an `ital` axis that `font-style: italic` activates). */
+    obliqueAngle?: number;
+}
+/** A raw `fontOptimized` doc's face fields, before ital-capability expansion. */
+type RawFace = ActiveFace & {
+    italCapable?: boolean;
+};
+/**
+ * Expand one typeface's raw faces into the served set: an upright, ital-capable variable face
+ * contributes an extra italic face over the same file — unless the typeface already has an
+ * explicit italic file, which always wins. Exported for reuse (the export endpoint applies the
+ * same rule) and for tests.
+ */
+export declare function expandItalCapableFaces(faces: RawFace[]): ActiveFace[];
+/** The typeface active for a family, plus its served faces. */
+export interface ActiveTypeface {
+    family: FontFamily;
+    id: string | number;
+    faces: ActiveFace[];
+}
+export interface GetActiveFontFacesOptions {
+    /** Slug of the standalone font-selection global. @default 'fontSet' */
+    fontSetSlug?: string;
+    /** Slug of the optimized (served) upload collection. @default 'fontOptimized' */
+    optimizedSlug?: string;
+    /** Family keys to read. Omit to auto-discover them from the `fontSet` global's own slots. */
+    families?: FontFamily[];
+}
+/**
+ * Resolve the active `fontSet` selection to each family's served `fontOptimized` files. Used by the
+ * {@link DevFonts} component (and available for custom font-serving) to build `@font-face` rules
+ * from CMS data at runtime. Returns `[]` if no global / no selection.
+ */
+export declare function getActiveFontFaces(payload: Payload, opts?: GetActiveFontFacesOptions): Promise<ActiveTypeface[]>;
+export interface BuildFontFaceCssOptions {
+    /** Prefix for the emitted CSS family variables; the capitalised family is appended (`--font-setSans`).
+     *  Must match the download CLI's `cssVariablePrefix`. @default '--font-set' */
+    cssVarPrefix?: string;
+    /** Slug used to build the served file URL. @default 'fontOptimized' */
+    optimizedSlug?: string;
+    /** Per-family CSS fallback stack override (`{ brand: 'Georgia, serif' }`). Falls back to the
+     *  built-in family defaults, then a generic sans stack. */
+    fallbacks?: Record<string, string>;
+}
+/**
+ * Build the `@font-face` rules + the `:root` family-variable mapping for a set of active typefaces.
+ * Pure (no IO) so it's easy to test; {@link DevFonts} wraps it with the CMS read. The family
+ * variables (`--font-setSans`, …) point at each typeface's served family, so the same
+ * `font-family: var(--font-setSans)` your app uses in production resolves identically in dev.
+ */
+export declare function buildFontFaceCss(typefaces: ActiveTypeface[], opts?: BuildFontFaceCssOptions): string;
+export {};
+//# sourceMappingURL=activeFonts.d.ts.map

package/dist/lib/activeFonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activeFonts.d.ts","sourceRoot":"","sources":["../../src/lib/activeFonts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA8B,OAAO,EAAE,MAAM,SAAS,CAAA;AAKlE,gGAAgG;AAChG,MAAM,MAAM,UAAU,GAAG,MAAM,CAAA;AAE/B;qGACqG;AACrG,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC1B;kFAC8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,iFAAiF;AACjF,KAAK,OAAO,GAAG,UAAU,GAAG;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAErD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,EAAE,CAUrE;AAED,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,UAAU,CAAA;IAClB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAA;CACxB;AAQD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,yBAA8B,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAoD1H;AAWD,MAAM,WAAW,uBAAuB;IACtC;mFAC+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;+DAC2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,EAAE,IAAI,GAAE,uBAA4B,GAAG,MAAM,CAmBxG"}

package/dist/lib/activeFonts.js

@@ -0,0 +1,139 @@
+import { refId } from "./refs.js";
+import { DEFAULT_FONT_FAMILIES, familyVarSuffix } from "./families.js";
+/**
+ * Expand one typeface's raw faces into the served set: an upright, ital-capable variable face
+ * contributes an extra italic face over the same file — unless the typeface already has an
+ * explicit italic file, which always wins. Exported for reuse (the export endpoint applies the
+ * same rule) and for tests.
+ */ export function expandItalCapableFaces(faces) {
+    const hasExplicitItalic = faces.some((f)=>f.style === 'italic');
+    return faces.flatMap(({ italCapable, ...face })=>{
+        // obliqueAngle is only meaningful on the synthesized italic face — never on an upright.
+        const { obliqueAngle: _drop, ...upright } = face;
+        if (face.style === 'normal' && italCapable && !hasExplicitItalic) {
+            return [
+                upright,
+                {
+                    ...face,
+                    style: 'italic'
+                }
+            ];
+        }
+        return [
+            face.style === 'normal' ? upright : face
+        ];
+    });
+}
+/** Payload global meta keys that aren't family slots — filtered out when auto-discovering. */ const GLOBAL_META_KEYS = new Set([
+    'id',
+    'globalType',
+    'createdAt',
+    'updatedAt'
+]);
+/** The family slots on a `fontSet` global doc: its own keys, minus Payload's metadata. */ const familyKeysFromGlobal = (global)=>global ? Object.keys(global).filter((k)=>!k.startsWith('_') && !GLOBAL_META_KEYS.has(k)) : [];
+/**
+ * Resolve the active `fontSet` selection to each family's served `fontOptimized` files. Used by the
+ * {@link DevFonts} component (and available for custom font-serving) to build `@font-face` rules
+ * from CMS data at runtime. Returns `[]` if no global / no selection.
+ */ export async function getActiveFontFaces(payload, opts = {}) {
+    const fontSetSlug = opts.fontSetSlug ?? 'fontSet';
+    const optimizedSlug = opts.optimizedSlug ?? 'fontOptimized';
+    let selection;
+    try {
+        // `as unknown as` — in a project with generated types findGlobal resolves to the concrete
+        // fontSet interface, which doesn't structurally overlap a string-keyed record.
+        selection = await payload.findGlobal({
+            slug: fontSetSlug,
+            depth: 0,
+            overrideAccess: true
+        });
+    } catch  {
+        return [] // fontSet global not registered
+        ;
+    }
+    // Explicit list, else auto-discover the family slots from the global itself — so a custom
+    // `families` set works here with no extra config (the global's slots are the source of truth).
+    const families = opts.families ?? familyKeysFromGlobal(selection);
+    // Resolve each family's selected typeface id once, then fetch every family's served files in a
+    // single query (grouped by typeface) rather than one round-trip per family.
+    const familyIds = families.map((family)=>({
+            family,
+            id: refId(selection?.[family])
+        })).filter((r)=>r.id != null);
+    if (!familyIds.length) return [];
+    const uniqueIds = [
+        ...new Set(familyIds.map((r)=>r.id))
+    ];
+    const res = await payload.find({
+        collection: optimizedSlug,
+        where: {
+            font: {
+                in: uniqueIds
+            }
+        },
+        depth: 0,
+        limit: 1000,
+        overrideAccess: true
+    });
+    const facesByFont = new Map();
+    for (const d of res.docs){
+        if (typeof d.filename !== 'string') continue;
+        const fontId = refId(d.font);
+        if (fontId == null) continue;
+        const face = {
+            filename: d.filename,
+            weight: d.weight || '400',
+            style: d.style === 'italic' ? 'italic' : 'normal',
+            ...d.italCapable ? {
+                italCapable: true
+            } : {},
+            ...typeof d.obliqueAngle === 'number' ? {
+                obliqueAngle: d.obliqueAngle
+            } : {}
+        };
+        const bucket = facesByFont.get(fontId);
+        if (bucket) bucket.push(face);
+        else facesByFont.set(fontId, [
+            face
+        ]);
+    }
+    const out = [];
+    for (const { family, id } of familyIds){
+        const faces = facesByFont.get(id);
+        if (faces?.length) out.push({
+            family,
+            id,
+            faces: expandItalCapableFaces(faces)
+        });
+    }
+    return out;
+}
+/** Generic CSS fallback stack for the built-in families, appended after the served family in the
+ *  family variable. Overridable per family via {@link BuildFontFaceCssOptions.fallbacks}. */ const GENERIC_FALLBACK = Object.fromEntries(DEFAULT_FONT_FAMILIES.map((r)=>[
+        r.key,
+        r.fallback
+    ]));
+/** Used for a custom family with no declared fallback. */ const DEFAULT_FALLBACK = 'ui-sans-serif, system-ui, sans-serif';
+/** Payload serves an upload file at `/api/<slug>/file/<filename>` (public read on `fontOptimized`). */ const faceUrl = (filename, slug)=>`/api/${slug}/file/${encodeURIComponent(filename)}`;
+/**
+ * Build the `@font-face` rules + the `:root` family-variable mapping for a set of active typefaces.
+ * Pure (no IO) so it's easy to test; {@link DevFonts} wraps it with the CMS read. The family
+ * variables (`--font-setSans`, …) point at each typeface's served family, so the same
+ * `font-family: var(--font-setSans)` your app uses in production resolves identically in dev.
+ */ export function buildFontFaceCss(typefaces, opts = {}) {
+    const cssVarPrefix = opts.cssVarPrefix ?? '--font-set';
+    const optimizedSlug = opts.optimizedSlug ?? 'fontOptimized';
+    const fallbackFor = (family)=>opts.fallbacks?.[family] ?? GENERIC_FALLBACK[family] ?? DEFAULT_FALLBACK;
+    if (!typefaces.length) return '';
+    const faces = typefaces.flatMap((tf)=>tf.faces.map((f)=>{
+            // An italic with an oblique angle rides a `slnt` axis: `font-style: oblique <angle>`
+            // maps onto it per CSS Fonts 4 (as `font-style: italic` maps onto an `ital` axis), and
+            // italic requests fall back to oblique faces in font matching.
+            const fontStyle = f.style === 'italic' && f.obliqueAngle ? `oblique ${f.obliqueAngle}deg` : f.style;
+            return `@font-face{font-family:'pl-font-${tf.id}';src:url('${faceUrl(f.filename, optimizedSlug)}') format('woff2');font-weight:${f.weight};font-style:${fontStyle};font-display:swap;}`;
+        })).join('');
+    const vars = typefaces.map((tf)=>`${cssVarPrefix}${familyVarSuffix(tf.family)}:'pl-font-${tf.id}',${fallbackFor(tf.family)};`).join('');
+    return `${faces}:root{${vars}}`;
+}
+
+//# sourceMappingURL=activeFonts.js.map

package/dist/lib/activeFonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/activeFonts.ts"],"sourcesContent":["import type { CollectionSlug, GlobalSlug, Payload } from 'payload'\n\nimport { refId } from './refs'\nimport { DEFAULT_FONT_FAMILIES, familyVarSuffix } from './families'\n\n/** A family key. `sans`/`serif`/`mono`/`display` by default, but any string when customised. */\nexport type FontFamily = string\n\n/** One served face. Usually one per `fontOptimized` doc — but an upright variable file whose\n *  axes also cover italics (`italCapable`) expands into a second, italic face over the SAME file. */\nexport interface ActiveFace {\n  filename: string\n  /** A single CSS weight ('400') or a variable range ('100 900'). */\n  weight: string\n  style: 'normal' | 'italic'\n  /** For slnt-based italics: the positive CSS `oblique` angle (deg). Absent = a true italic\n   *  (explicit file, or an `ital` axis that `font-style: italic` activates). */\n  obliqueAngle?: number\n}\n\n/** A raw `fontOptimized` doc's face fields, before ital-capability expansion. */\ntype RawFace = ActiveFace & { italCapable?: boolean }\n\n/**\n * Expand one typeface's raw faces into the served set: an upright, ital-capable variable face\n * contributes an extra italic face over the same file — unless the typeface already has an\n * explicit italic file, which always wins. Exported for reuse (the export endpoint applies the\n * same rule) and for tests.\n */\nexport function expandItalCapableFaces(faces: RawFace[]): ActiveFace[] {\n  const hasExplicitItalic = faces.some((f) => f.style === 'italic')\n  return faces.flatMap(({ italCapable, ...face }) => {\n    // obliqueAngle is only meaningful on the synthesized italic face — never on an upright.\n    const { obliqueAngle: _drop, ...upright } = face\n    if (face.style === 'normal' && italCapable && !hasExplicitItalic) {\n      return [upright, { ...face, style: 'italic' as const }]\n    }\n    return [face.style === 'normal' ? upright : face]\n  })\n}\n\n/** The typeface active for a family, plus its served faces. */\nexport interface ActiveTypeface {\n  family: FontFamily\n  id: string | number\n  faces: ActiveFace[]\n}\n\nexport interface GetActiveFontFacesOptions {\n  /** Slug of the standalone font-selection global. @default 'fontSet' */\n  fontSetSlug?: string\n  /** Slug of the optimized (served) upload collection. @default 'fontOptimized' */\n  optimizedSlug?: string\n  /** Family keys to read. Omit to auto-discover them from the `fontSet` global's own slots. */\n  families?: FontFamily[]\n}\n\n/** Payload global meta keys that aren't family slots — filtered out when auto-discovering. */\nconst GLOBAL_META_KEYS = new Set(['id', 'globalType', 'createdAt', 'updatedAt'])\n/** The family slots on a `fontSet` global doc: its own keys, minus Payload's metadata. */\nconst familyKeysFromGlobal = (global: Record<string, unknown> | null | undefined): FontFamily[] =>\n  global ? Object.keys(global).filter((k) => !k.startsWith('_') && !GLOBAL_META_KEYS.has(k)) : []\n\n/**\n * Resolve the active `fontSet` selection to each family's served `fontOptimized` files. Used by the\n * {@link DevFonts} component (and available for custom font-serving) to build `@font-face` rules\n * from CMS data at runtime. Returns `[]` if no global / no selection.\n */\nexport async function getActiveFontFaces(payload: Payload, opts: GetActiveFontFacesOptions = {}): Promise<ActiveTypeface[]> {\n  const fontSetSlug = (opts.fontSetSlug ?? 'fontSet') as GlobalSlug\n  const optimizedSlug = (opts.optimizedSlug ?? 'fontOptimized') as CollectionSlug\n\n  let selection: Partial<Record<FontFamily, unknown>>\n  try {\n    // `as unknown as` — in a project with generated types findGlobal resolves to the concrete\n    // fontSet interface, which doesn't structurally overlap a string-keyed record.\n    selection = (await payload.findGlobal({ slug: fontSetSlug, depth: 0, overrideAccess: true })) as unknown as Partial<\n      Record<FontFamily, unknown>\n    >\n  } catch {\n    return [] // fontSet global not registered\n  }\n\n  // Explicit list, else auto-discover the family slots from the global itself — so a custom\n  // `families` set works here with no extra config (the global's slots are the source of truth).\n  const families = opts.families ?? familyKeysFromGlobal(selection as Record<string, unknown>)\n\n  // Resolve each family's selected typeface id once, then fetch every family's served files in a\n  // single query (grouped by typeface) rather than one round-trip per family.\n  const familyIds = families\n    .map((family) => ({ family, id: refId(selection?.[family]) }))\n    .filter((r): r is { family: FontFamily; id: string | number } => r.id != null)\n  if (!familyIds.length) return []\n\n  const uniqueIds = [...new Set(familyIds.map((r) => r.id))]\n  const res = await payload.find({ collection: optimizedSlug, where: { font: { in: uniqueIds } }, depth: 0, limit: 1000, overrideAccess: true })\n\n  const facesByFont = new Map<string | number, RawFace[]>()\n  for (const d of res.docs as unknown as Array<Record<string, unknown>>) {\n    if (typeof d.filename !== 'string') continue\n    const fontId = refId(d.font)\n    if (fontId == null) continue\n    const face: RawFace = {\n      filename: d.filename,\n      weight: (d.weight as string) || '400',\n      style: d.style === 'italic' ? 'italic' : 'normal',\n      ...(d.italCapable ? { italCapable: true } : {}),\n      ...(typeof d.obliqueAngle === 'number' ? { obliqueAngle: d.obliqueAngle } : {}),\n    }\n    const bucket = facesByFont.get(fontId)\n    if (bucket) bucket.push(face)\n    else facesByFont.set(fontId, [face])\n  }\n\n  const out: ActiveTypeface[] = []\n  for (const { family, id } of familyIds) {\n    const faces = facesByFont.get(id)\n    if (faces?.length) out.push({ family, id, faces: expandItalCapableFaces(faces) })\n  }\n  return out\n}\n\n/** Generic CSS fallback stack for the built-in families, appended after the served family in the\n *  family variable. Overridable per family via {@link BuildFontFaceCssOptions.fallbacks}. */\nconst GENERIC_FALLBACK: Record<string, string> = Object.fromEntries(DEFAULT_FONT_FAMILIES.map((r) => [r.key, r.fallback]))\n/** Used for a custom family with no declared fallback. */\nconst DEFAULT_FALLBACK = 'ui-sans-serif, system-ui, sans-serif'\n\n/** Payload serves an upload file at `/api/<slug>/file/<filename>` (public read on `fontOptimized`). */\nconst faceUrl = (filename: string, slug: string) => `/api/${slug}/file/${encodeURIComponent(filename)}`\n\nexport interface BuildFontFaceCssOptions {\n  /** Prefix for the emitted CSS family variables; the capitalised family is appended (`--font-setSans`).\n   *  Must match the download CLI's `cssVariablePrefix`. @default '--font-set' */\n  cssVarPrefix?: string\n  /** Slug used to build the served file URL. @default 'fontOptimized' */\n  optimizedSlug?: string\n  /** Per-family CSS fallback stack override (`{ brand: 'Georgia, serif' }`). Falls back to the\n   *  built-in family defaults, then a generic sans stack. */\n  fallbacks?: Record<string, string>\n}\n\n/**\n * Build the `@font-face` rules + the `:root` family-variable mapping for a set of active typefaces.\n * Pure (no IO) so it's easy to test; {@link DevFonts} wraps it with the CMS read. The family\n * variables (`--font-setSans`, …) point at each typeface's served family, so the same\n * `font-family: var(--font-setSans)` your app uses in production resolves identically in dev.\n */\nexport function buildFontFaceCss(typefaces: ActiveTypeface[], opts: BuildFontFaceCssOptions = {}): string {\n  const cssVarPrefix = opts.cssVarPrefix ?? '--font-set'\n  const optimizedSlug = opts.optimizedSlug ?? 'fontOptimized'\n  const fallbackFor = (family: FontFamily) => opts.fallbacks?.[family] ?? GENERIC_FALLBACK[family] ?? DEFAULT_FALLBACK\n  if (!typefaces.length) return ''\n\n  const faces = typefaces\n    .flatMap((tf) =>\n      tf.faces.map((f) => {\n        // An italic with an oblique angle rides a `slnt` axis: `font-style: oblique <angle>`\n        // maps onto it per CSS Fonts 4 (as `font-style: italic` maps onto an `ital` axis), and\n        // italic requests fall back to oblique faces in font matching.\n        const fontStyle = f.style === 'italic' && f.obliqueAngle ? `oblique ${f.obliqueAngle}deg` : f.style\n        return `@font-face{font-family:'pl-font-${tf.id}';src:url('${faceUrl(f.filename, optimizedSlug)}') format('woff2');font-weight:${f.weight};font-style:${fontStyle};font-display:swap;}`\n      }),\n    )\n    .join('')\n  const vars = typefaces.map((tf) => `${cssVarPrefix}${familyVarSuffix(tf.family)}:'pl-font-${tf.id}',${fallbackFor(tf.family)};`).join('')\n  return `${faces}:root{${vars}}`\n}\n"],"names":["refId","DEFAULT_FONT_FAMILIES","familyVarSuffix","expandItalCapableFaces","faces","hasExplicitItalic","some","f","style","flatMap","italCapable","face","obliqueAngle","_drop","upright","GLOBAL_META_KEYS","Set","familyKeysFromGlobal","global","Object","keys","filter","k","startsWith","has","getActiveFontFaces","payload","opts","fontSetSlug","optimizedSlug","selection","findGlobal","slug","depth","overrideAccess","families","familyIds","map","family","id","r","length","uniqueIds","res","find","collection","where","font","in","limit","facesByFont","Map","d","docs","filename","fontId","weight","bucket","get","push","set","out","GENERIC_FALLBACK","fromEntries","key","fallback","DEFAULT_FALLBACK","faceUrl","encodeURIComponent","buildFontFaceCss","typefaces","cssVarPrefix","fallbackFor","fallbacks","tf","fontStyle","join","vars"],"mappings":"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"}