fix(cli): a font missing from this computer no longer stops a cloud render, and is named (#7287)

* fix(cli): a font missing from this computer no longer stops a cloud render, and is named

* style(cli): format the font preflight files and trim two new comments

* style(cli): the embedSystemFonts doc fits in two lines
This commit is contained in:
Miguel Ángel
2026-11-06 02:10:06 +00:00
committed by GitHub
parent 6abc62a179
commit b56e2c0366
4 changed files with 87 additions and 47 deletions
+34 -9
View File
@@ -2,7 +2,7 @@ import { mkdtempSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { describe, expect, it } from "vitest";
import { describeUnresolvedFonts, embedSystemFonts } from "./fontPreflight.js";
import { describeSwappedFonts, embedSystemFonts } from "./fontPreflight.js";
const PAGE = `<html><head><style>h1{font-family:"PingFang SC"}</style></head><body><h1>x</h1></body></html>`;
@@ -29,6 +29,7 @@ describe("embedSystemFonts", () => {
});
expect(left).toEqual([]);
expect(calls.map((c) => c.allowSystemFontCapture)).toEqual([false, true]);
expect(calls.map((c) => c.failClosedFontFetch)).toEqual([true, false]);
expect(calls.map((c) => c.systemFontsByInnerName)).toEqual([undefined, true]);
// The resolver only injects into a full document, so the probe for the capture pass must be one.
expect(probes[1]).toContain("<head>");
@@ -37,13 +38,37 @@ describe("embedSystemFonts", () => {
expect(entry.indexOf("data-hf-system-fonts")).toBeLessThan(entry.indexOf("</head>"));
});
it("returns the fonts whose file is not on this machine and leaves the page alone", async () => {
it("gives a font with no file on this machine an empty face and returns it, instead of stopping", async () => {
const s = setup();
const left = await embedSystemFonts(s, async () => {
const left = await embedSystemFonts(s, async (html, options) => {
if ((options as { allowSystemFontCapture: boolean }).allowSystemFontCapture) return html;
throw missing(["PingFang SC"]);
});
expect(left).toEqual(["PingFang SC"]);
expect(s.fileMap.get("index.html")!.toString()).toBe(PAGE);
const entry = s.fileMap.get("index.html")!.toString();
expect(entry).toContain(
'@font-face{font-family:"PingFang SC";src:local("hyperframes-font-not-installed',
);
expect(entry).not.toContain("data:font");
});
it("carries the fonts it finds even when another one is not on this machine", async () => {
const page = `<html><head><style>a{font-family:"PingFang SC"}b{font-family:"Zapfino"}</style></head><body></body></html>`;
const fileMap = new Map([["index.html", Buffer.from(page)]]);
const dir = mkdtempSync(join(tmpdir(), "hf-font-pre-"));
writeFileSync(join(dir, "index.html"), page);
const left = await embedSystemFonts(
{ dir, entryPath: "index.html", fileMap },
async (html, options) => {
if ((options as { allowSystemFontCapture: boolean }).allowSystemFontCapture)
return `${html}<style>@font-face{font-family:"PingFang SC";src:url(data:font/woff2;base64,AAAA)}</style>`;
throw missing(["PingFang SC", "Zapfino"]);
},
);
expect(left).toEqual(["Zapfino"]);
const entry = fileMap.get("index.html")!.toString();
expect(entry).toContain('font-family:"PingFang SC";src:url(data:font/woff2');
expect(entry).toContain('font-family:"Zapfino";src:local(');
});
it("changes nothing when every font resolves", async () => {
@@ -61,11 +86,11 @@ describe("embedSystemFonts", () => {
});
});
describe("describeUnresolvedFonts", () => {
it("names the font and a look-alike when there is one", () => {
expect(describeUnresolvedFonts(["PingFang SC", "Zapfino"])).toBe(
"HyperFrames couldn't find a font file for PingFang SC on this computer, so the cloud can't have it: use Noto Sans SC, switch to a font in your project or render on this computer.\n" +
"HyperFrames couldn't find a font file for Zapfino on this computer, so the cloud can't have it: switch to a font in your project or render on this computer.",
describe("describeSwappedFonts", () => {
it("names each font that is not on this computer and a look-alike when there is one", () => {
expect(describeSwappedFonts(["PingFang SC", "Zapfino"])).toBe(
"PingFang SC is not on this computer, so it renders in the next font of its stack (or the default font), as a local render does; Noto Sans SC is a free look-alike you can use instead.\n" +
"Zapfino is not on this computer, so it renders in the next font of its stack (or the default font), as a local render does.",
);
});
});
+32 -20
View File
@@ -71,9 +71,19 @@ async function unresolvedCloudFonts(
}
}
const faceFamily = (face: string) =>
/font-family\s*:\s*(?:"([^"]+)"|'([^']+)'|([^;}"']+))/i
.exec(face)
?.slice(1)
.find(Boolean)
?.trim();
const placeholderFace = (family: string) =>
`@font-face{font-family:"${family}";src:local("hyperframes-font-not-installed ${family}")}`;
/**
* Adds the system fonts the project uses to its entry page as inline @font-face rules, so the zip carries them.
* Returns the families whose font file is not on this machine; those cannot render in the cloud.
* A family with no font file here gets an empty face (the local fallback) and is returned for the caller to name.
*/
export async function embedSystemFonts(
opts: { dir: string; entryFile?: string; entryPath: string; fileMap: Map<string, StagedFile> },
@@ -84,23 +94,25 @@ export async function embedSystemFonts(
if (wanted.length === 0) return [];
const css = wanted.map((f, i) => `.f${i}{font-family:"${f}"}`).join("");
const probe = `<!doctype html><html><head><style>${css}</style></head><body></body></html>`;
let out: string;
try {
out = await run(probe, {
failClosedFontFetch: true,
allowSystemFontCapture: true,
systemFontsByInnerName: true,
logger: QUIET,
});
} catch (err) {
return namedFamilies(err) ?? wanted;
}
const faces = [...out.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/g)]
const out = await run(probe, {
failClosedFontFetch: false,
allowSystemFontCapture: true,
systemFontsByInnerName: true,
logger: QUIET,
});
const captured = [...out.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/g)]
.map((m) => m[1] ?? "")
.filter((css) => css.includes("@font-face"))
.join("\n");
const found = new Set(
[...captured.matchAll(/@font-face\s*{[^}]*}/gi)]
.map((m) => faceFamily(m[0])?.toLowerCase())
.filter((f): f is string => f !== undefined),
);
const missing = wanted.filter((family) => !found.has(family.toLowerCase()));
const faces = [captured, ...missing.map(placeholderFace)].filter(Boolean).join("\n");
const entry = opts.fileMap.get(opts.entryPath);
if (!faces || !entry) return wanted;
if (!entry) return missing;
const html = readStaged(entry).toString("utf-8");
const tag = `<style data-hf-system-fonts>${faces}</style>`;
const at = html.search(/<\/head>/i);
@@ -108,17 +120,17 @@ export async function embedSystemFonts(
opts.entryPath,
Buffer.from(at < 0 ? tag + html : html.slice(0, at) + tag + html.slice(at), "utf-8"),
);
return [];
return missing;
}
/** One line per font, with the swap when there is one. */
export function describeUnresolvedFonts(families: readonly string[]): string {
/** One line per font that is not on this computer: the cloud renders it with the same fallback a local render uses. */
export function describeSwappedFonts(families: readonly string[]): string {
return families
.map((family) => {
const swap = lookAlikeFor(family);
return `HyperFrames couldn't find a font file for ${family} on this computer, so the cloud can't have it: ${
swap ? `use ${swap}, ` : ""
}switch to a font in your project or render on this computer.`;
return `${family} is not on this computer, so it renders in the next font of its stack (or the default font), as a local render does${
swap ? `; ${swap} is a free look-alike you can use instead` : ""
}.`;
})
.join("\n");
}
@@ -11,7 +11,7 @@ vi.mock("../../cloud/fontPreflight.js", async (importOriginal) => ({
import render from "./render.js";
import { errorBox } from "../../ui/format.js";
import { CliRuntimeError, consumeCommandResult } from "../../utils/commandResult.js";
import { consumeCommandResult } from "../../utils/commandResult.js";
vi.mock("../../ui/format.js", async (importOriginal) => ({
...(await importOriginal<typeof import("../../ui/format.js")>()),
@@ -40,17 +40,16 @@ afterEach(() => {
});
describe("cloud render font preflight", () => {
it("stops before any upload and names the font that is not on this computer", async () => {
await expect(runCommand(render, { rawArgs: [project, "--no-wait", "--json"] })).rejects.toThrow(
CliRuntimeError,
);
it("does not stop for a font that is not on this computer: the dry run names it and carries on", async () => {
const lines: string[] = [];
const log = vi
.spyOn(console, "log")
.mockImplementation((line) => void lines.push(String(line)));
await runCommand(render, { rawArgs: [project, "--dry-run", "--json"] });
log.mockRestore();
expect(fetchSpy).not.toHaveBeenCalled();
expect(errorBox).toHaveBeenCalledWith(
"Fonts not on this computer",
expect.stringContaining(
"HyperFrames couldn't find a font file for PingFang SC on this computer, so the cloud can't have it: use Noto Sans SC",
),
);
expect(errorBox).not.toHaveBeenCalled();
expect(JSON.parse(lines.join("")).archive.swapped_fonts).toEqual(["PingFang SC"]);
});
});
+11 -7
View File
@@ -73,7 +73,7 @@ import {
pollUntilTerminal,
} from "../../cloud/index.js";
import { reportApiError } from "../../cloud/errors.js";
import { describeUnresolvedFonts, embedSystemFonts } from "../../cloud/fontPreflight.js";
import { describeSwappedFonts, embedSystemFonts } from "../../cloud/fontPreflight.js";
import { parseEnumFlag, parseIntFlag, parseNumericFlag } from "../../cloud/parsing.js";
import { uploadAssetViaDirectUpload, uploadZipViaDirectUpload } from "../../cloud/upload.js";
import {
@@ -325,7 +325,10 @@ export default defineCommand({
if (asJson) {
console.log(
JSON.stringify(
withMeta({ render: { render_id: renderId, status: "queued" as const } }),
withMeta({
render: { render_id: renderId, status: "queued" as const },
swapped_fonts: preparedArchive?.swappedFonts ?? [],
}),
null,
2,
),
@@ -370,6 +373,7 @@ export default defineCommand({
render: detail,
output_path: outputPath,
bytes_written: downloadResult.bytes,
swapped_fonts: preparedArchive?.swappedFonts ?? [],
}),
null,
2,
@@ -649,6 +653,7 @@ interface PreparedLocalArchive {
fileCount: number;
largestFiles: ArchiveFileSummary[];
offloaded: OffloadedMedia[];
swappedFonts: string[];
}
function summarizeLargestFiles(fileMap: Map<string, StagedFile>): ArchiveFileSummary[] {
@@ -671,16 +676,13 @@ async function prepareLocalArchive(
console.log(`${c.accent("◆")} Zipping ${c.accent(project.name)}`);
}
const { fileMap, entryPath } = stageProjectFiles(project, composition);
const missingFonts = await embedSystemFonts({
const swappedFonts = await embedSystemFonts({
dir: project.dir,
entryFile: composition,
entryPath,
fileMap,
});
if (missingFonts.length > 0) {
errorBox("Fonts not on this computer", describeUnresolvedFonts(missingFonts));
failCommand();
}
if (swappedFonts.length > 0 && !asJson) console.log(c.dim(describeSwappedFonts(swappedFonts)));
const offloaded = await offloadMedia(project, fileMap, entryPath, asJson, upload, variablesText);
// Media left on disk barely compresses: past the limit, its size is the report and nothing is read.
@@ -703,6 +705,7 @@ async function prepareLocalArchive(
fileCount: fileMap.size,
largestFiles,
offloaded,
swappedFonts,
};
if (upload) assertArchiveFits(sizeBytes, largestFiles);
if (!asJson && sizeBytes >= ARCHIVE_DIAGNOSTIC_THRESHOLD_BYTES) {
@@ -828,6 +831,7 @@ function reportDryRun(prepared: PreparedLocalArchive, asJson: boolean): void {
exceeds_upload_limit: sizeBytes > DIRECT_UPLOAD_LIMIT_BYTES,
largest_files: prepared.largestFiles,
offloaded_media: prepared.offloaded,
swapped_fonts: prepared.swappedFonts,
},
}),
null,