wasm-html-to-image 1.0.11 → 1.0.13

package/dist/core-orchestrate.js

@@ -132,7 +132,7 @@ export function createOrchestration(module, options) {
         limits,
         resolveResource,
         diag,
-        usage: { resourceCount: 0, totalResourceBytes: 0 },
+        usage: { resourceCount: 0, totalResourceBytes: 0, fontsSkippedByCount: 0 },
         t0,
         emitLog,
         addTime,

package/dist/core-resources.d.ts

@@ -37,6 +37,8 @@ export interface DiagState {
 export interface ResourceUsage {
     resourceCount: number;
     totalResourceBytes: number;
+    /** Font files dropped because `maxResourceCount` was reached (across all rounds). */
+    fontsSkippedByCount: number;
 }
 /** Resolution context threaded through HTML discovery (internal). */
 export interface ResolveContext {

package/dist/core-resources.js

@@ -108,7 +108,8 @@ async function fetchResourceBytesInner(url, baseUrl, userAgent, timeoutMs, confi
     const headers = userAgent && isNodeRuntime() ? { "User-Agent": userAgent } : undefined;
     // Abort hung connections so one stalled server cannot outlive `timeoutMs`.
     const signal = timeoutMs !== undefined
-        ? AbortSignal.timeout(Math.max(1, timeoutMs))
+        ? // Node >= 24 requires an integer delay; the remaining budget is fractional.
+            AbortSignal.timeout(Math.max(1, Math.ceil(timeoutMs)))
         : undefined;
     const fetchBytes = async (target) => {
         // Servers may vary the body by User-Agent (e.g. woff2 vs ttf CSS).
@@ -440,7 +441,16 @@ export async function resolveHtmlResources(module, satoruInst, htmls, width, hei
         // later sheet must not land before (and so lose to) a large earlier one. They are
         // buffered here and injected in discovery order once the whole round has settled.
         const loadedCss = [];
-        await mapWithLimit(pending, FETCH_CONCURRENCY, async (r) => {
+        // When maxResourceCount cuts a round short, what is dropped should be the least harmful: a missing
+        // image leaves a hole, a missing font turns the whole text into tofu. Stylesheets go first (they
+        // cascade by document order and may reveal more), then fonts, then images; discovery order is
+        // kept within each kind.
+        const rank = (t) => (t === "css" ? 0 : t === "font" ? 1 : 2);
+        const ordered = pending
+            .map((r, i) => ({ r, i }))
+            .sort((a, b) => rank(a.r.type) - rank(b.r.type) || a.i - b.i)
+            .map((e) => e.r);
+        await mapWithLimit(ordered, FETCH_CONCURRENCY, async (r) => {
             const diag = ctx.diag;
             const entry = diag
                 ? {
@@ -482,6 +492,8 @@ export async function resolveHtmlResources(module, satoruInst, htmls, width, hei
                 if (ctx.limits.maxResourceCount !== undefined &&
                     ctx.usage.resourceCount >= ctx.limits.maxResourceCount) {
                     const message = `Maximum resource count (${ctx.limits.maxResourceCount}) exceeded`;
+                    if (r.type === "font")
+                        ctx.usage.fontsSkippedByCount++;
                     skipWithError(DIAGNOSTIC_CODES.LIMIT_RESOURCE_COUNT, message);
                     return;
                 }
@@ -546,6 +558,21 @@ export async function resolveHtmlResources(module, satoruInst, htmls, width, hei
             (await addRes(satoruInst, css.url, 3, bytes));
         }
     }
+    if (ctx.usage.fontsSkippedByCount > 0) {
+        // Text in those fonts renders as tofu: say what to change instead of leaving a silent bad image.
+        // One message for the whole render, however many discovery rounds hit the limit.
+        const message = `${ctx.usage.fontsSkippedByCount} font file(s) were not loaded because maxResourceCount ` +
+            `(${ctx.limits.maxResourceCount}) was reached; text using them may render as missing glyphs. ` +
+            "Raise limits.maxResourceCount (a Google Fonts stylesheet alone can reference over a hundred files).";
+        ctx.diag?.warnings.push({
+            code: DIAGNOSTIC_CODES.LIMIT_RESOURCE_COUNT,
+            message,
+        });
+        ctx.emitLog(LogLevel.Warning, message);
+        if (ctx.limits.strictFonts) {
+            throw new Error(`[${DIAGNOSTIC_CODES.LIMIT_RESOURCE_COUNT}] ${message}`);
+        }
+    }
     // Merge the C++ collect-phase breakdown into the JS timings.
     if (profileEnabled && ctx.diag) {
         const getProfile = module.satoru_get_collect_profile;

package/dist/diagnostics.d.ts

@@ -108,6 +108,11 @@ export interface RenderLimits {
     maxTotalResourceBytes?: number;
     /** Maximum number of resources to load. */
     maxResourceCount?: number;
+    /**
+     * Throw (code `LIMIT_RESOURCE_COUNT`) instead of rendering when font files had to be skipped
+     * because of `maxResourceCount`, so text is never silently drawn as missing glyphs. Default `false`.
+     */
+    strictFonts?: boolean;
     /** Allowed URL protocols (e.g. `["http:", "https:"]`). */
     allowedProtocols?: string[];
     /** Allowed hostnames. */