react-native-nano-icons 0.1.1 → 0.1.3

package/lib/commonjs/src/core/svg/layers.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computePlacement = computePlacement;
 exports.writeLayerSvg = writeLayerSvg;
+exports.transformPathForFont = transformPathForFont;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 function roundInt(n) {
@@ -40,3 +41,29 @@ async function writeLayerSvg(opts) {
     </svg>`.trim();
     await promises_1.default.writeFile(node_path_1.default.join(opts.tempDir, `u${hex}.svg`), layerSvg, 'utf8');
 }
+/**
+ * Transform an SVG path `d` string from source SVG coordinates into font
+ * glyph coordinates (Y-up, with placement scaling and centering applied).
+ *
+ * Combines placement transform (translate + scale + translate) with the
+ * SVG→font Y-axis flip into a single affine transform applied via PathKit.
+ */
+function transformPathForFont(PathKit, d, opts) {
+    const { vx, vy, scale, xOff, yOff, upm } = opts;
+    const p = PathKit.FromSVGString(d);
+    if (!p)
+        return d;
+    // Combined affine: placement + Y-flip for font coordinates.
+    //   x' =  scale * (x - vx) + xOff
+    //   y' =  upm - (scale * (y - vy) + yOff)
+    //
+    // SkMatrix row-major: [scaleX, skewX, transX, skewY, scaleY, transY, 0,0,1]
+    const scaleX = scale;
+    const scaleY = -scale;
+    const transX = xOff - vx * scale;
+    const transY = upm - yOff + vy * scale;
+    p.transform(scaleX, 0, transX, 0, scaleY, transY, 0, 0, 1);
+    const result = p.toSVGString();
+    p.delete?.();
+    return result;
+}

package/lib/commonjs/src/core/svg/svg_dom.d.ts

@@ -3,14 +3,27 @@ export type ParsedFlatSvg = {
     paths: Array<{
         d: string;
         fill: string | null;
+        fillRule?: 'evenodd';
     }>;
 };
 export declare function calculateOpColor(fill: string | null, opacity: number, el: Element): `rgba(${number},${number},${number},${number})`;
+/**
+ * If a flattened path lost its initial moveto (e.g. picosvg dropped an empty
+ * `Mx y z` subpath), prepend `M` using the path's last coordinate pair.
+ * For closed icon shapes the endpoint equals the start point.
+ */
+export declare function sanitizePathData(d: string): {
+    d: string;
+    sanitized: boolean;
+};
 export declare const parsePath: (p: Element) => {
     d: string;
     fill: string | null;
+    fillRule?: "evenodd";
 };
-export declare function parseFlattenedSvg(flattenedSvg: string): ParsedFlatSvg;
+export declare function parseFlattenedSvg(flattenedSvg: string, options?: {
+    onSanitize?: (original: string) => void;
+}): ParsedFlatSvg;
 export declare function shouldSkipPath(d: string, fill: string | null): boolean;
 export type SvgValidation = {
     valid: true;
@@ -19,4 +32,19 @@ export type SvgValidation = {
     reason: string;
 };
 export declare function validateSvg(content: string): SvgValidation;
+/**
+ * Extract the original `d` strings of evenodd paths from the raw SVG
+ * BEFORE picosvg processes it. Picosvg's simplify (via our PathKit shim)
+ * can drop contours from multi-subpath evenodd paths, so we preserve
+ * the originals and apply our own winding conversion later.
+ *
+ * Returns one `d` string per evenodd path, in document order.
+ */
+export declare function extractOriginalEvenoddDs(svgContent: string): string[];
+/**
+ * Replace picosvg's (potentially damaged) evenodd path data with the
+ * preserved originals. Matches by position: the Nth evenodd path in
+ * the parsed output gets the Nth original `d` string.
+ */
+export declare function restoreOriginalEvenoddDs(paths: ParsedFlatSvg['paths'], originalDs: string[]): void;
 export declare function preprocessSvg(content: string): string;

package/lib/commonjs/src/core/svg/svg_dom.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePath = void 0;
 exports.calculateOpColor = calculateOpColor;
+exports.sanitizePathData = sanitizePathData;
 exports.parseFlattenedSvg = parseFlattenedSvg;
 exports.shouldSkipPath = shouldSkipPath;
 exports.validateSvg = validateSvg;
+exports.extractOriginalEvenoddDs = extractOriginalEvenoddDs;
+exports.restoreOriginalEvenoddDs = restoreOriginalEvenoddDs;
 exports.preprocessSvg = preprocessSvg;
 const jsdom_1 = require("jsdom");
 const parse_1 = require("../../utils/parse");
@@ -26,11 +29,36 @@ function calculateOpColor(fill, opacity, el) {
     const finalAlpha = +(a * opacity).toFixed(4);
     return `rgba(${r},${g},${b},${finalAlpha})`;
 }
+/**
+ * If a flattened path lost its initial moveto (e.g. picosvg dropped an empty
+ * `Mx y z` subpath), prepend `M` using the path's last coordinate pair.
+ * For closed icon shapes the endpoint equals the start point.
+ */
+function sanitizePathData(d) {
+    const trimmed = d.trim();
+    if (!trimmed || /^[Mm]/.test(trimmed)) {
+        return { d: trimmed, sanitized: false };
+    }
+    // Strip trailing close commands, then grab the last two numbers as x,y
+    const withoutClose = trimmed.replace(/[Zz]\s*$/, '');
+    const nums = withoutClose.match(/-?\d+(?:\.\d+)?/g);
+    if (!nums || nums.length < 2) {
+        return { d: trimmed, sanitized: false };
+    }
+    const x = nums[nums.length - 2];
+    const y = nums[nums.length - 1];
+    return { d: `M${x},${y} ${trimmed}`, sanitized: true };
+}
 const parsePath = (p) => {
     const d = p.getAttribute('d') ?? '';
     const op = p.getAttribute('opacity');
     const fillOp = p.getAttribute('fill-opacity');
     const fill = p.getAttribute('fill');
+    // picosvg may drop fill-rule but preserve clip-rule; treat either as evenodd
+    const fillRule = p.getAttribute('fill-rule') === 'evenodd' ||
+        p.getAttribute('clip-rule') === 'evenodd'
+        ? 'evenodd'
+        : undefined;
     if (op !== null || fillOp !== null) {
         const opVal = op !== null ? parseFloat(op) : 1;
         const fillOpVal = fillOp !== null ? parseFloat(fillOp) : 1;
@@ -38,15 +66,17 @@ const parsePath = (p) => {
         return {
             d,
             fill: calculateOpColor(fill, combinedOpacity, p),
+            fillRule,
         };
     }
     return {
         d,
         fill,
+        fillRule,
     };
 };
 exports.parsePath = parsePath;
-function parseFlattenedSvg(flattenedSvg) {
+function parseFlattenedSvg(flattenedSvg, options) {
     const dom = new jsdom_1.JSDOM(flattenedSvg);
     const doc = dom.window.document;
     const svgEl = doc.querySelector('svg');
@@ -58,7 +88,16 @@ function parseFlattenedSvg(flattenedSvg) {
         ? [viewBoxRaw[0], viewBoxRaw[1], viewBoxRaw[2], viewBoxRaw[3]]
         : [0, 0, 100, 100];
     const pathEls = Array.from(doc.querySelectorAll('path'));
-    const paths = pathEls.map(exports.parsePath).filter((p) => p.d.trim() !== '');
+    const paths = pathEls
+        .map(exports.parsePath)
+        .filter((p) => p.d.trim() !== '')
+        .map((p) => {
+        const { d, sanitized } = sanitizePathData(p.d);
+        if (sanitized) {
+            options?.onSanitize?.(p.d);
+        }
+        return { ...p, d };
+    });
     return { viewBox, paths };
 }
 function shouldSkipPath(d, fill) {
@@ -76,6 +115,43 @@ function validateSvg(content) {
     }
     return { valid: true };
 }
+/**
+ * Extract the original `d` strings of evenodd paths from the raw SVG
+ * BEFORE picosvg processes it. Picosvg's simplify (via our PathKit shim)
+ * can drop contours from multi-subpath evenodd paths, so we preserve
+ * the originals and apply our own winding conversion later.
+ *
+ * Returns one `d` string per evenodd path, in document order.
+ */
+function extractOriginalEvenoddDs(svgContent) {
+    if (!/<[^>]*fill-rule\s*=\s*["']evenodd/i.test(svgContent)) {
+        return [];
+    }
+    const dom = new jsdom_1.JSDOM(svgContent, { contentType: 'image/svg+xml' });
+    const doc = dom.window.document;
+    const results = [];
+    const pathEls = doc.querySelectorAll('path[fill-rule="evenodd"], path[clip-rule="evenodd"]');
+    for (const el of pathEls) {
+        const d = el.getAttribute('d');
+        if (d)
+            results.push(d);
+    }
+    return results;
+}
+/**
+ * Replace picosvg's (potentially damaged) evenodd path data with the
+ * preserved originals. Matches by position: the Nth evenodd path in
+ * the parsed output gets the Nth original `d` string.
+ */
+function restoreOriginalEvenoddDs(paths, originalDs) {
+    let oi = 0;
+    for (const p of paths) {
+        if (p.fillRule === 'evenodd' && oi < originalDs.length) {
+            p.d = originalDs[oi];
+            oi++;
+        }
+    }
+}
 // ensure the svg has a xmlns attribute
 function preprocessSvg(content) {
     if (/xmlns\s*=/.test(content))

package/lib/commonjs/src/core/svg/svg_pathops.d.ts

@@ -1,4 +1,15 @@
 import type { PathKitModule, WrappedPath, Point } from '../types.js';
+/**
+ * Convert a path `d` string with evenodd fill semantics to an equivalent
+ * path that renders identically under nonzero winding.
+ *
+ * Steps:
+ * 1. Parse via PathKit, set fill type to EVENODD, simplify (resolve topology)
+ * 2. Split into contours, compute containment depths
+ * 3. Fix winding: even depth = CCW (outer), odd depth = CW (hole)
+ * 4. Reconstruct d string
+ */
+export declare function convertEvenoddToWinding(PathKit: PathKitModule, d: string): string;
 export declare function buildPathopsBackend(PathKit: PathKitModule): {
     create_path(fillTypeInt: number): WrappedPath;
     clone_path(h: WrappedPath): WrappedPath;

package/lib/commonjs/src/core/svg/svg_pathops.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEvenoddToWinding = convertEvenoddToWinding;
 exports.buildPathopsBackend = buildPathopsBackend;
 //** */
 // ----- numeric helpers -----
@@ -381,9 +382,11 @@ function bestStartMinYMinX(contourCmds, VERB) {
     }
     return best;
 }
-// proxy to for picosvg to interatc with pathkit
-function buildPathopsBackend(PathKit) {
-    const VERB = {
+// ---------------------------------------------------------------------------
+// Containment helpers (module-level for reuse by fixPathWinding)
+// ---------------------------------------------------------------------------
+function buildVerbMap(PathKit) {
+    return {
         MOVE: PathKit.MOVE_VERB ?? 0,
         LINE: PathKit.LINE_VERB ?? 1,
         QUAD: PathKit.QUAD_VERB ?? 2,
@@ -391,6 +394,206 @@ function buildPathopsBackend(PathKit) {
         CUBIC: PathKit.CUBIC_VERB ?? 4,
         CLOSE: PathKit.CLOSE_VERB ?? 5,
     };
+}
+/**
+ * Convert contour commands to a polyline by sampling curves.
+ * Used for ray-casting containment tests.
+ */
+function contourToPolyline(contourCmds, V, steps = 8) {
+    let cx = 0, cy = 0;
+    let sx = 0, sy = 0;
+    const pts = [];
+    for (const cmd of contourCmds) {
+        const v = cmd[0];
+        if (v === V.MOVE) {
+            cx = cmd[1];
+            cy = cmd[2];
+            sx = cx;
+            sy = cy;
+            pts.push([cx, cy]);
+        }
+        else if (v === V.LINE) {
+            cx = cmd[1];
+            cy = cmd[2];
+            pts.push([cx, cy]);
+        }
+        else if (v === V.QUAD) {
+            const x0 = cx, y0 = cy;
+            const x1 = cmd[1], y1 = cmd[2];
+            const x2 = cmd[3], y2 = cmd[4];
+            for (let i = 1; i <= steps; i++) {
+                const t = i / steps;
+                const mt = 1 - t;
+                pts.push([mt * mt * x0 + 2 * mt * t * x1 + t * t * x2, mt * mt * y0 + 2 * mt * t * y1 + t * t * y2]);
+            }
+            cx = x2;
+            cy = y2;
+        }
+        else if (v === V.CUBIC) {
+            const x0 = cx, y0 = cy;
+            const x1 = cmd[1], y1 = cmd[2];
+            const x2 = cmd[3], y2 = cmd[4];
+            const x3 = cmd[5], y3 = cmd[6];
+            for (let i = 1; i <= steps; i++) {
+                const t = i / steps;
+                const mt = 1 - t;
+                pts.push([
+                    mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3,
+                    mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3,
+                ]);
+            }
+            cx = x3;
+            cy = y3;
+        }
+        else if (v === V.CLOSE) {
+            if (cx !== sx || cy !== sy)
+                pts.push([sx, sy]);
+            cx = sx;
+            cy = sy;
+        }
+    }
+    return pts;
+}
+/**
+ * Ray-casting point-in-polygon test.
+ */
+function pointInPolygon(px, py, poly) {
+    let inside = false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const [xi, yi] = poly[i];
+        const [xj, yj] = poly[j];
+        if (yi > py !== yj > py &&
+            px < ((xj - xi) * (py - yi)) / (yj - yi) + xi) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+/**
+ * Get a representative point on the contour boundary (midpoint of first segment).
+ */
+function getContourSamplePoint(contourCmds, V) {
+    let cx = 0, cy = 0;
+    for (const cmd of contourCmds) {
+        const v = cmd[0];
+        if (v === V.MOVE) {
+            cx = cmd[1];
+            cy = cmd[2];
+        }
+        else if (v === V.LINE) {
+            return [(cx + cmd[1]) / 2, (cy + cmd[2]) / 2];
+        }
+        else if (v === V.QUAD) {
+            const t = 0.5, mt = 0.5;
+            return [
+                mt * mt * cx + 2 * mt * t * cmd[1] + t * t * cmd[3],
+                mt * mt * cy + 2 * mt * t * cmd[2] + t * t * cmd[4],
+            ];
+        }
+        else if (v === V.CUBIC) {
+            const t = 0.5, mt = 0.5;
+            return [
+                mt ** 3 * cx + 3 * mt ** 2 * t * cmd[1] + 3 * mt * t ** 2 * cmd[3] + t ** 3 * cmd[5],
+                mt ** 3 * cy + 3 * mt ** 2 * t * cmd[2] + 3 * mt * t ** 2 * cmd[4] + t ** 3 * cmd[6],
+            ];
+        }
+    }
+    return null;
+}
+/**
+ * Apply containment-based winding fix to contour objects.
+ * Even nesting depth = CCW (outer), odd = CW (hole).
+ */
+function applyContainmentWinding(contourObjs, V) {
+    const n = contourObjs.length;
+    if (n === 0)
+        return;
+    const polylines = contourObjs.map((obj) => contourToPolyline(obj.cmds, V));
+    const samplePts = contourObjs.map((obj) => getContourSamplePoint(obj.cmds, V));
+    const depths = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+        const pt = samplePts[i];
+        if (!pt)
+            continue;
+        for (let j = 0; j < n; j++) {
+            if (i === j)
+                continue;
+            if (pointInPolygon(pt[0], pt[1], polylines[j])) {
+                depths[i] = (depths[i] ?? 0) + 1;
+            }
+        }
+    }
+    const ensureOrient = (obj, wantCCW) => {
+        const a = approxSignedAreaFromContourCmds(obj.cmds, V);
+        const isCCW = a > 0;
+        if (wantCCW !== isCCW) {
+            obj.cmds = reverseClosedContourKeepStart(obj.cmds, obj.explicitCloseWanted, V);
+        }
+    };
+    for (let i = 0; i < n; i++) {
+        ensureOrient(contourObjs[i], depths[i] % 2 === 0);
+    }
+}
+/**
+ * Convert a path `d` string with evenodd fill semantics to an equivalent
+ * path that renders identically under nonzero winding.
+ *
+ * Steps:
+ * 1. Parse via PathKit, set fill type to EVENODD, simplify (resolve topology)
+ * 2. Split into contours, compute containment depths
+ * 3. Fix winding: even depth = CCW (outer), odd depth = CW (hole)
+ * 4. Reconstruct d string
+ */
+function convertEvenoddToWinding(PathKit, d) {
+    const V = buildVerbMap(PathKit);
+    // 1. Parse and simplify with EVENODD fill type
+    const p = PathKit.FromSVGString(d);
+    if (!p)
+        return d;
+    const FILL_EVENODD = PathKit?.FillType?.EVENODD ?? PathKit?.FillType?.EVEN_ODD ?? 1;
+    p.setFillType(FILL_EVENODD);
+    p.simplify();
+    // Get the simplified SVG string and re-parse for command access
+    const simplified = p.toSVGString();
+    p.delete?.();
+    const p2 = PathKit.FromSVGString(simplified);
+    if (!p2)
+        return simplified;
+    const cmds = p2.toCmds();
+    p2.delete?.();
+    if (cmds.length === 0)
+        return simplified;
+    // 2. Split into contours
+    const contourObjs = splitContours(cmds, V).map((c) => {
+        const explicitCloseWanted = explicitCloseWantedFromCmds(c, V);
+        const cc = ensureClosed(c, V);
+        const a = approxSignedAreaFromContourCmds(cc, V);
+        return { cmds: cc, absA: Math.abs(a), explicitCloseWanted };
+    });
+    contourObjs.sort((x, y) => y.absA - x.absA);
+    // 3. Fix winding via containment analysis
+    applyContainmentWinding(contourObjs, V);
+    // 4. Reconstruct d string from fixed commands
+    const allCmds = contourObjs.flatMap((x) => x.cmds);
+    const parts = [];
+    for (const cmd of allCmds) {
+        const v = cmd[0];
+        if (v === V.MOVE)
+            parts.push(`M${roundN(cmd[1])} ${roundN(cmd[2])}`);
+        else if (v === V.LINE)
+            parts.push(`L${roundN(cmd[1])} ${roundN(cmd[2])}`);
+        else if (v === V.QUAD)
+            parts.push(`Q${roundN(cmd[1])} ${roundN(cmd[2])} ${roundN(cmd[3])} ${roundN(cmd[4])}`);
+        else if (v === V.CUBIC)
+            parts.push(`C${roundN(cmd[1])} ${roundN(cmd[2])} ${roundN(cmd[3])} ${roundN(cmd[4])} ${roundN(cmd[5])} ${roundN(cmd[6])}`);
+        else if (v === V.CLOSE)
+            parts.push('Z');
+    }
+    return parts.join(' ');
+}
+// proxy to for picosvg to interatc with pathkit
+function buildPathopsBackend(PathKit) {
+    const VERB = buildVerbMap(PathKit);
     const FILL_EVENODD = PathKit?.FillType?.EVENODD ?? PathKit?.FillType?.EVEN_ODD ?? 1;
     const FILL_WINDING = PathKit?.FillType?.WINDING ?? PathKit?.FillType?.NONZERO ?? 0;
     function cmdsViaSvgRoundtrip(h) {
@@ -413,22 +616,9 @@ function buildPathopsBackend(PathKit) {
         });
         // Big-to-small ordering gives deterministic outer→inner ordering.
         contourObjs.sort((x, y) => y.absA - x.absA);
-        // Enforce winding convention:
-        // - largest contour CCW (positive area)
-        // - all subsequent contours CW (negative area)
-        const ensureOrient = (obj, wantCCW) => {
-            const a = approxSignedAreaFromContourCmds(obj.cmds, VERB);
-            const isCCW = a > 0;
-            if (wantCCW !== isCCW) {
-                obj.cmds = reverseClosedContourKeepStart(obj.cmds, obj.explicitCloseWanted, VERB);
-            }
-        };
-        if (contourObjs.length) {
-            ensureOrient(contourObjs[0], true);
-            for (let i = 1; i < contourObjs.length; i++) {
-                ensureOrient(contourObjs[i], false);
-            }
-        }
+        // Containment-based winding: compute nesting depth per contour via
+        // ray-casting point-in-polygon. Even depth = outer (CCW), odd = hole (CW).
+        applyContainmentWinding(contourObjs, VERB);
         // Rotate starts deterministically:
         // 1) If we have recorded MOVE points, try to rotate contour to a move point that lies on it.
         // 2) Otherwise, rotate to minY/minX point (helps stroke-ish paths)

package/lib/commonjs/src/core/types.d.ts

@@ -99,22 +99,37 @@ export type PyodideModule = {
         get: (key: string) => unknown;
     };
 };
-export type GlyphLayer = {
-    codepoint: number;
-    color: string;
-};
-export type GlyphEntry = {
-    adv: number;
-    layers: GlyphLayer[];
-};
+export type GlyphLayer = [codepoint: number, color: string];
+export type GlyphEntry = [adv: number, layers: GlyphLayer[]];
 export type IconsMap = Record<string, GlyphEntry>;
+/**
+ * m - metadata,
+ *   f - font family,
+ *   u - units per em,
+ *   z - safe zone,
+ *   s - start unicode,
+ *   h - hash,
+ * i - icons,
+ *   adv - advance width,
+ */
 export type NanoGlyphMap = {
-    meta: {
-        fontFamily: string;
-        upm: number;
-        safeZone: number;
-        startUnicode: number;
-        hash?: string;
+    m: {
+        f: string;
+        u: number;
+        z: number;
+        s: number;
+        h?: string;
+    };
+    i: IconsMap;
+};
+/** Accepts JSON-inferred types where arrays aren't tuples. */
+export type NanoGlyphMapInput = {
+    m: {
+        f: string;
+        u: number;
+        z: number;
+        s: number;
+        h?: string;
     };
-    icons: IconsMap;
+    i: Record<string, readonly unknown[]>;
 };

package/lib/module/core/font/compile.js

@@ -2,32 +2,59 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { once } from 'node:events';
 import { forceTtfMetrics } from './metrics.js';
 import svg2ttf from 'svg2ttf';
-import { parseCodepointFromFilename } from '../../utils/parse.js';
-async function writeGlyphStreamToFont(fontStream, svgPath, filename) {
-  const codepoint = parseCodepointFromFilename(filename);
-  const name = path.basename(filename, '.svg');
-  return new Promise((resolve, reject) => {
-    const glyphStream = fs.createReadStream(svgPath);
-    glyphStream.metadata = {
-      name,
-      unicode: [String.fromCodePoint(codepoint)]
-    };
-    glyphStream.on('error', reject);
-    // Do not add fontStream.on("error", reject) here — one per glyph would exceed
-    // Node's default MaxListeners (10). Font stream errors are handled once below.
-    fontStream.write(glyphStream);
-    glyphStream.on('end', resolve);
-  });
+function escapeXml(s) {
+  return s.replace(/&/g, '&').replace(/"/g, '"');
 }
-export async function compileTtfFromGlyphSVGs(opts) {
+
+/**
+ * Build an SVG font XML string from pre-transformed glyph data.
+ */
+function buildSvgFontXml(opts) {
   const {
-    SVGIcons2SVGFontStream
-  } = await import('svgicons2svgfont');
+    fontName,
+    glyphs,
+    upm,
+    ascent,
+    descent
+  } = opts;
+  const glyphLines = glyphs.map(g => {
+    const hex = g.codepoint.toString(16);
+    const name = `u${hex.padStart(4, '0')}`;
+    return `<glyph glyph-name="${name}" unicode="&#x${hex};" horiz-adv-x="${g.advanceWidth}" d="${escapeXml(g.d)}"/>`;
+  });
+  return `<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg">
+<defs>
+<font id="${escapeXml(fontName)}" horiz-adv-x="${upm}">
+<font-face font-family="${escapeXml(fontName)}" units-per-em="${upm}" ascent="${ascent}" descent="${-Math.abs(descent)}"/>
+<missing-glyph horiz-adv-x="0"/>
+${glyphLines.join('\n')}
+</font>
+</defs>
+</svg>`;
+}
+export function parseCompileTtfFromGlyphsError(err, codepointToIcon) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const cpMatch = msg.match(/glyph\s+"u([0-9a-fA-F]+)"/);
+  if (cpMatch) {
+    const cp = parseInt(cpMatch[1], 16);
+    const iconName = codepointToIcon.get(cp);
+    const detail = iconName ? `icon "${iconName}" (codepoint u${cpMatch[1]})` : `codepoint u${cpMatch[1]}`;
+    throw new Error(`Font compilation failed for ${detail}: ${msg}`);
+  }
+  throw err;
+}
+
+/**
+ * Compile a TTF font from pre-transformed glyph data.
+ * Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+ */
+export async function compileTtfFromGlyphs(opts) {
   const {
-    glyphDir,
+    glyphs,
     outTtfPath,
     fontName,
     upm,
@@ -35,30 +62,14 @@ export async function compileTtfFromGlyphSVGs(opts) {
     descent
   } = opts;
   const lineGap = opts.lineGap ?? 0;
-  const files = fs.readdirSync(glyphDir).filter(f => /^u[0-9a-fA-F]+\.svg$/.test(f)).sort((a, b) => parseCodepointFromFilename(a) - parseCodepointFromFilename(b));
-  if (files.length === 0) throw new Error(`No glyph SVGs found in: ${glyphDir}`);
-  const fontStream = new SVGIcons2SVGFontStream({
+  if (glyphs.length === 0) throw new Error('No glyphs to compile');
+  const svgFontString = buildSvgFontXml({
     fontName,
-    fontHeight: upm,
-    normalize: false,
+    glyphs,
+    upm,
     ascent,
     descent
   });
-  const svgFontChunks = [];
-  fontStream.on('data', c => svgFontChunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
-
-  // Single error listener for the font stream; per-glyph errors are handled in writeGlyphStreamToFont.
-  let fontStreamReject;
-  const fontStreamErrorPromise = new Promise((_, rej) => {
-    fontStreamReject = rej;
-  });
-  fontStream.on('error', err => fontStreamReject(err));
-  for (const f of files) {
-    await Promise.race([writeGlyphStreamToFont(fontStream, path.join(glyphDir, f), f), fontStreamErrorPromise]);
-  }
-  fontStream.end();
-  await once(fontStream, 'end');
-  const svgFontString = Buffer.concat(svgFontChunks).toString('utf8');
   const ttfRaw = svg2ttf(svgFontString);
   const rawBuf = Buffer.from(ttfRaw.buffer);
   const fixedBuf = forceTtfMetrics(rawBuf, upm, ascent, descent, lineGap);