@forgeax/engine-font 0.1.4 → 0.1.7

package/src/__tests__/font.unit.test.ts

@@ -9,7 +9,7 @@
 // Paradigm: each block-scoped describe('<source-filename>.test.ts', ...) preserves
 // source as ancestorTitles[0]. Top-level imports merged + deduped.
 
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -173,653 +173,6 @@ async function findRealTtf(): Promise<string | undefined> {
         expect((err as FontError).code).toBe('bake-failed');
         expect((err as FontError).detail?.cause).toBe('wasm boom');
       });
-
-      it('(d) output-root refusal is structured before generator work and repairs on the same path', async () => {
-        const ttfPath = join(tmpRoot, 'Valid.ttf');
-        await writeFile(ttfPath, TTF_MAGIC);
-        const blockedParent = join(tmpRoot, 'blocked-parent');
-        const outDir = join(blockedParent, 'atlas');
-        await writeFile(blockedParent, 'not a directory');
-
-        let factoryCalls = 0;
-        let generateCalls = 0;
-        let disposeCalls = 0;
-        const factory = async (): Promise<MsdfGenerator> => {
-          factoryCalls += 1;
-          return {
-            generateAtlas: async (bytes) => {
-              generateCalls += 1;
-              expect(bytes).toEqual(TTF_MAGIC);
-              return {
-                texture: { width: 1, height: 1, data: new Uint8Array([255, 255, 255, 255]) },
-                glyphs: [],
-                metrics: { lineHeight: 1, ascender: 1 },
-                textureSize: [1, 1],
-                fieldRange: 4,
-              };
-            },
-            dispose: async () => {
-              disposeCalls += 1;
-            },
-          };
-        };
-
-        const refusal = await bakeFont(ttfPath, outDir, factory).catch((error) => error);
-        expect(refusal).toBeInstanceOf(FontError);
-        expect(refusal).toMatchObject({ code: 'bake-failed' });
-        expect((refusal as FontError).detail).toMatchObject({ path: outDir });
-        expect(typeof (refusal as FontError).detail?.cause).toBe('string');
-        expect((refusal as FontError).detail?.cause).toContain('ENOTDIR');
-        expect((refusal as FontError).hint).toContain('output');
-        expect(factoryCalls).toBe(0);
-        expect(generateCalls).toBe(0);
-        expect(disposeCalls).toBe(0);
-        await expect(stat(join(outDir, 'Valid.atlas.png'))).rejects.toMatchObject({
-          code: 'ENOTDIR',
-        });
-        await expect(stat(join(outDir, 'Valid.meta.json'))).rejects.toMatchObject({
-          code: 'ENOTDIR',
-        });
-
-        await rm(blockedParent);
-        await mkdir(blockedParent);
-        const repaired = await bakeFont(ttfPath, outDir, factory);
-        const repairedAtlas = await readFile(repaired.atlasPath);
-        const repairedSidecar = await readFile(repaired.sidecarPath, 'utf8');
-        expect(repaired).toEqual({
-          atlasPath: join(outDir, 'Valid.atlas.png'),
-          sidecarPath: join(outDir, 'Valid.meta.json'),
-        });
-        expect(factoryCalls).toBe(1);
-        expect(generateCalls).toBe(1);
-        expect(disposeCalls).toBe(1);
-
-        const repeated = await bakeFont(ttfPath, outDir, factory);
-        expect(await readFile(repeated.atlasPath)).toEqual(repairedAtlas);
-        expect(await readFile(repeated.sidecarPath, 'utf8')).toBe(repairedSidecar);
-        expect(repeated).toEqual(repaired);
-        expect(factoryCalls).toBe(2);
-        expect(generateCalls).toBe(2);
-        expect(disposeCalls).toBe(2);
-      });
-
-      it('(d2) atlas-target refusal is structured and repairs on the same path', async () => {
-        const ttfPath = join(tmpRoot, 'Valid.ttf');
-        const outDir = join(tmpRoot, 'output');
-        await writeFile(ttfPath, TTF_MAGIC);
-        await mkdir(outDir);
-        const atlasPath = join(outDir, 'Valid.atlas.png');
-        const sidecarPath = join(outDir, 'Valid.meta.json');
-        await mkdir(atlasPath);
-
-        let factoryCalls = 0;
-        let generateCalls = 0;
-        let disposeCalls = 0;
-        const factory = async (): Promise<MsdfGenerator> => {
-          factoryCalls += 1;
-          return {
-            generateAtlas: async (bytes) => {
-              generateCalls += 1;
-              expect(bytes).toEqual(TTF_MAGIC);
-              return {
-                texture: { width: 1, height: 1, data: new Uint8Array([255, 0, 255, 255]) },
-                glyphs: [],
-                metrics: { lineHeight: 1, ascender: 1 },
-                textureSize: [1, 1],
-                fieldRange: 4,
-              };
-            },
-            dispose: async () => {
-              disposeCalls += 1;
-            },
-          };
-        };
-
-        const refusal = await bakeFont(ttfPath, outDir, factory).catch((error) => error);
-        expect(refusal).toBeInstanceOf(FontError);
-        expect(refusal).toMatchObject({
-          code: 'bake-failed',
-          hint: expect.stringContaining('atlas'),
-          detail: {
-            path: atlasPath,
-            cause: expect.stringContaining('EISDIR'),
-          },
-        });
-        expect((refusal as FontError).detail?.cause).toContain(atlasPath);
-        const refusedTarget = await stat(atlasPath);
-        expect(refusedTarget.isDirectory()).toBe(true);
-        await expect(stat(sidecarPath)).rejects.toMatchObject({ code: 'ENOENT' });
-        expect(factoryCalls).toBe(1);
-        expect(generateCalls).toBe(1);
-        expect(disposeCalls).toBe(1);
-
-        await rm(atlasPath, { recursive: true, force: true });
-        const repaired = await bakeFont(ttfPath, outDir, factory);
-        const repairedAtlas = await readFile(repaired.atlasPath);
-        const repairedSidecar = await readFile(repaired.sidecarPath, 'utf8');
-        expect(repaired).toEqual({ atlasPath, sidecarPath });
-        expect(factoryCalls).toBe(2);
-        expect(generateCalls).toBe(2);
-        expect(disposeCalls).toBe(2);
-
-        const repeated = await bakeFont(ttfPath, outDir, factory);
-        expect(await readFile(repeated.atlasPath)).toEqual(repairedAtlas);
-        expect(await readFile(repeated.sidecarPath, 'utf8')).toBe(repairedSidecar);
-        expect(repeated).toEqual(repaired);
-        expect(factoryCalls).toBe(3);
-        expect(generateCalls).toBe(3);
-        expect(disposeCalls).toBe(3);
-      });
-
-      it('(d3) sidecar-target refusal is structured and repairs on the same path', async () => {
-        const ttfPath = join(tmpRoot, 'Valid.ttf');
-        const outDir = join(tmpRoot, 'output');
-        await writeFile(ttfPath, TTF_MAGIC);
-        await mkdir(outDir);
-        const atlasPath = join(outDir, 'Valid.atlas.png');
-        const sidecarPath = join(outDir, 'Valid.meta.json');
-        await mkdir(sidecarPath);
-
-        let factoryCalls = 0;
-        let generateCalls = 0;
-        let disposeCalls = 0;
-        const factory = async (): Promise<MsdfGenerator> => {
-          factoryCalls += 1;
-          return {
-            generateAtlas: async (bytes) => {
-              generateCalls += 1;
-              expect(bytes).toEqual(TTF_MAGIC);
-              return {
-                texture: { width: 1, height: 1, data: new Uint8Array([255, 64, 128, 255]) },
-                glyphs: [],
-                metrics: { lineHeight: 1, ascender: 1 },
-                textureSize: [1, 1],
-                fieldRange: 4,
-              };
-            },
-            dispose: async () => {
-              disposeCalls += 1;
-            },
-          };
-        };
-
-        const refusal = await bakeFont(ttfPath, outDir, factory).catch((error) => error);
-        expect(refusal).toBeInstanceOf(FontError);
-        expect(refusal).toMatchObject({
-          code: 'bake-failed',
-          expected: expect.stringContaining('sidecar'),
-          hint: expect.stringContaining('sidecar'),
-          detail: {
-            path: sidecarPath,
-            cause: expect.stringContaining('EISDIR'),
-          },
-        });
-        expect((refusal as FontError).code).not.toBe('EISDIR');
-        expect('atlasPath' in (refusal as object)).toBe(false);
-        const cause = (refusal as FontError).detail?.cause;
-        expect(typeof cause).toBe('string');
-        expect((cause as string).length).toBeLessThan(1024);
-        expect((await stat(sidecarPath)).isDirectory()).toBe(true);
-        const refusedAtlas = await readFile(atlasPath);
-        expect(refusedAtlas.length).toBeGreaterThan(0);
-        expect(factoryCalls).toBe(1);
-        expect(generateCalls).toBe(1);
-        expect(disposeCalls).toBe(1);
-
-        await rm(sidecarPath, { recursive: true, force: true });
-        const repaired = await bakeFont(ttfPath, outDir, factory);
-        const repairedAtlas = await readFile(repaired.atlasPath);
-        const repairedSidecar = await readFile(repaired.sidecarPath, 'utf8');
-        expect(repaired).toEqual({ atlasPath, sidecarPath });
-        expect(repairedAtlas).toEqual(refusedAtlas);
-        expect(JSON.parse(repairedSidecar)).toMatchObject({ importer: 'font' });
-        expect(factoryCalls).toBe(2);
-        expect(generateCalls).toBe(2);
-        expect(disposeCalls).toBe(2);
-
-        const repeated = await bakeFont(ttfPath, outDir, factory);
-        expect(await readFile(repeated.atlasPath)).toEqual(repairedAtlas);
-        expect(await readFile(repeated.sidecarPath, 'utf8')).toBe(repairedSidecar);
-        expect(repeated).toEqual(repaired);
-        expect(factoryCalls).toBe(3);
-        expect(generateCalls).toBe(3);
-        expect(disposeCalls).toBe(3);
-      });
-
-      it('(d4) malformed atlas textures fail before publication and repair on the same factory', async () => {
-        const ttfPath = join(tmpRoot, 'MalformedAtlas.ttf');
-        await writeFile(ttfPath, TTF_MAGIC);
-
-        const repairedAtlas: BakeAtlas = {
-          texture: { width: 2, height: 2, data: new Uint8Array(16) },
-          glyphs: [
-            {
-              unicode: 65,
-              advance: 10,
-              xoffset: 1,
-              yoffset: 2,
-              atlasPosition: [0, 0],
-              atlasSize: [1, 1],
-            },
-          ],
-          metrics: { lineHeight: 20, ascender: 16 },
-          textureSize: [2, 2],
-          fieldRange: 4,
-        };
-
-        const malformedCases: readonly [string, (atlas: BakeAtlas) => BakeAtlas][] = [
-          [
-            'non-positive-dimension',
-            (atlas) => ({
-              ...atlas,
-              texture: { ...atlas.texture, width: 0 },
-            }),
-          ],
-          [
-            'non-finite-dimension',
-            (atlas) => ({
-              ...atlas,
-              texture: { ...atlas.texture, height: Number.NaN },
-            }),
-          ],
-          [
-            'non-integer-dimension',
-            (atlas) => ({
-              ...atlas,
-              texture: { ...atlas.texture, width: 1.5 },
-            }),
-          ],
-          [
-            'rgba-length-mismatch',
-            (atlas) => ({
-              ...atlas,
-              texture: { ...atlas.texture, data: new Uint8Array(15) },
-            }),
-          ],
-          [
-            'texture-size-mismatch',
-            (atlas) => ({
-              ...atlas,
-              textureSize: [1, 2],
-            }),
-          ],
-        ];
-
-        for (const [caseName, makeMalformed] of malformedCases) {
-          const outDir = join(tmpRoot, `malformed-${caseName}`);
-          const atlasPath = join(outDir, 'MalformedAtlas.atlas.png');
-          const sidecarPath = join(outDir, 'MalformedAtlas.meta.json');
-          let returnMalformed = true;
-          let factoryCalls = 0;
-          let generateCalls = 0;
-          let disposeCalls = 0;
-          const factory = async (): Promise<MsdfGenerator> => {
-            factoryCalls += 1;
-            return {
-              generateAtlas: async (bytes) => {
-                generateCalls += 1;
-                expect(bytes).toEqual(TTF_MAGIC);
-                return returnMalformed ? makeMalformed(repairedAtlas) : repairedAtlas;
-              },
-              dispose: async () => {
-                disposeCalls += 1;
-              },
-            };
-          };
-
-          const refusal = await bakeFont(ttfPath, outDir, factory).catch((error) => error);
-          expect(refusal).toBeInstanceOf(FontError);
-          expect(refusal).toMatchObject({
-            code: 'bake-failed',
-            expected: expect.stringContaining('atlas'),
-            hint: expect.stringContaining('atlas'),
-            detail: { cause: expect.stringContaining('malformed-atlas') },
-          });
-          const cause = (refusal as FontError).detail?.cause;
-          expect(typeof cause).toBe('string');
-          expect((cause as string).length).toBeLessThan(256);
-          expect('atlasPath' in (refusal as object)).toBe(false);
-          await expect(stat(atlasPath)).rejects.toMatchObject({ code: 'ENOENT' });
-          await expect(stat(sidecarPath)).rejects.toMatchObject({ code: 'ENOENT' });
-          expect(factoryCalls).toBe(1);
-          expect(generateCalls).toBe(1);
-          expect(disposeCalls).toBe(1);
-
-          returnMalformed = false;
-          const repaired = await bakeFont(ttfPath, outDir, factory);
-          const repairedAtlasBytes = await readFile(repaired.atlasPath);
-          const repairedSidecar = await readFile(repaired.sidecarPath, 'utf8');
-          expect(repaired).toEqual({ atlasPath, sidecarPath });
-          expect(JSON.parse(repairedSidecar)).toMatchObject({
-            common: { atlasWidth: 2, atlasHeight: 2 },
-            glyphs: {
-              '65': {
-                advance: 10,
-                bearingX: 1,
-                bearingY: 2,
-                size: { w: 1, h: 1 },
-                region: { x: 0, y: 0, w: 1, h: 1 },
-              },
-            },
-          });
-          expect(factoryCalls).toBe(2);
-          expect(generateCalls).toBe(2);
-          expect(disposeCalls).toBe(2);
-
-          const repeated = await bakeFont(ttfPath, outDir, factory);
-          expect(repeated).toEqual(repaired);
-          expect(await readFile(repeated.atlasPath)).toEqual(repairedAtlasBytes);
-          expect(await readFile(repeated.sidecarPath, 'utf8')).toBe(repairedSidecar);
-          expect(factoryCalls).toBe(3);
-          expect(generateCalls).toBe(3);
-          expect(disposeCalls).toBe(3);
-        }
-      });
-
-      it('(d5) malformed glyph metrics fail before publication and repair on the same factory', async () => {
-        const ttfPath = join(tmpRoot, 'MalformedGlyphs.ttf');
-        await writeFile(ttfPath, TTF_MAGIC);
-
-        const validAtlas: BakeAtlas = {
-          texture: { width: 2, height: 2, data: new Uint8Array(16) },
-          glyphs: [
-            {
-              unicode: 65,
-              advance: 10,
-              xoffset: 1,
-              yoffset: 2,
-              atlasPosition: [0, 0],
-              atlasSize: [1, 1],
-            },
-          ],
-          metrics: { lineHeight: 20, ascender: 16 },
-          textureSize: [2, 2],
-          fieldRange: 4,
-        };
-        const baseGlyph = validAtlas.glyphs[0];
-        if (baseGlyph === undefined) {
-          throw new Error('test fixture must contain a base glyph');
-        }
-        const malformedCases: readonly [string, (atlas: BakeAtlas) => BakeAtlas][] = [
-          [
-            'non-finite-metric',
-            (atlas) => ({
-              ...atlas,
-              glyphs: [{ ...baseGlyph, advance: Number.NaN }],
-            }),
-          ],
-          [
-            'duplicate-unicode',
-            (atlas) => ({
-              ...atlas,
-              glyphs: [...atlas.glyphs, { ...baseGlyph, atlasPosition: [1, 0] }],
-            }),
-          ],
-          [
-            'out-of-atlas-region',
-            (atlas) => ({
-              ...atlas,
-              glyphs: [{ ...baseGlyph, atlasPosition: [1, 1], atlasSize: [2, 1] }],
-            }),
-          ],
-        ];
-
-        for (const [caseName, makeMalformed] of malformedCases) {
-          const outDir = join(tmpRoot, `malformed-glyph-${caseName}`);
-          const atlasPath = join(outDir, 'MalformedGlyphs.atlas.png');
-          const sidecarPath = join(outDir, 'MalformedGlyphs.meta.json');
-          let returnMalformed = true;
-          let factoryCalls = 0;
-          let generateCalls = 0;
-          let disposeCalls = 0;
-          const factory = async (): Promise<MsdfGenerator> => {
-            factoryCalls += 1;
-            return {
-              generateAtlas: async (bytes) => {
-                generateCalls += 1;
-                expect(bytes).toEqual(TTF_MAGIC);
-                return returnMalformed ? makeMalformed(validAtlas) : validAtlas;
-              },
-              dispose: async () => {
-                disposeCalls += 1;
-              },
-            };
-          };
-
-          const refusal = await bakeFont(ttfPath, outDir, factory).catch((error) => error);
-          expect(refusal).toBeInstanceOf(FontError);
-          expect(refusal).toMatchObject({
-            code: 'bake-failed',
-            expected: expect.stringContaining('glyph'),
-            hint: expect.stringContaining('glyph'),
-            detail: { cause: expect.stringContaining('malformed-glyph') },
-          });
-          const cause = (refusal as FontError).detail?.cause;
-          expect(typeof cause).toBe('string');
-          expect((cause as string).length).toBeLessThan(256);
-          expect('atlasPath' in (refusal as object)).toBe(false);
-          await expect(stat(atlasPath)).rejects.toMatchObject({ code: 'ENOENT' });
-          await expect(stat(sidecarPath)).rejects.toMatchObject({ code: 'ENOENT' });
-          expect(factoryCalls).toBe(1);
-          expect(generateCalls).toBe(1);
-          expect(disposeCalls).toBe(1);
-
-          returnMalformed = false;
-          const repaired = await bakeFont(ttfPath, outDir, factory);
-          const repairedAtlasBytes = await readFile(repaired.atlasPath);
-          const repairedSidecar = await readFile(repaired.sidecarPath, 'utf8');
-          expect(repaired).toEqual({ atlasPath, sidecarPath });
-          expect(factoryCalls).toBe(2);
-          expect(generateCalls).toBe(2);
-          expect(disposeCalls).toBe(2);
-
-          const repeated = await bakeFont(ttfPath, outDir, factory);
-          expect(repeated).toEqual(repaired);
-          expect(await readFile(repeated.atlasPath)).toEqual(repairedAtlasBytes);
-          expect(await readFile(repeated.sidecarPath, 'utf8')).toBe(repairedSidecar);
-          expect(factoryCalls).toBe(3);
-          expect(generateCalls).toBe(3);
-          expect(disposeCalls).toBe(3);
-        }
-      });
-
-      it('(d6) generator disposal rejection is structured and preserves primary failure', async () => {
-        const ttfPath = join(tmpRoot, 'GeneratorDispose.ttf');
-        await writeFile(ttfPath, TTF_MAGIC);
-
-        const validAtlas: BakeAtlas = {
-          texture: { width: 2, height: 2, data: new Uint8Array(16) },
-          glyphs: [
-            {
-              unicode: 65,
-              advance: 10,
-              xoffset: 1,
-              yoffset: 2,
-              atlasPosition: [0, 0],
-              atlasSize: [1, 1],
-            },
-          ],
-          metrics: { lineHeight: 20, ascender: 16 },
-          textureSize: [2, 2],
-          fieldRange: 4,
-        };
-        const cases: readonly [string, 'dispose' | 'primary'][] = [
-          ['dispose-rejection', 'dispose'],
-          ['primary-failure-preservation', 'primary'],
-        ];
-
-        for (const [caseName, failure] of cases) {
-          const outDir = join(tmpRoot, `generator-dispose-${caseName}`);
-          const atlasPath = join(outDir, 'GeneratorDispose.atlas.png');
-          const sidecarPath = join(outDir, 'GeneratorDispose.meta.json');
-          let fail = true;
-          let factoryCalls = 0;
-          let generateCalls = 0;
-          let disposeCalls = 0;
-          const factory = async (): Promise<MsdfGenerator> => {
-            factoryCalls += 1;
-            return {
-              generateAtlas: async (bytes) => {
-                generateCalls += 1;
-                expect(bytes).toEqual(TTF_MAGIC);
-                if (failure === 'primary' && fail) {
-                  throw new Error('primary generator failure');
-                }
-                return validAtlas;
-              },
-              dispose: async () => {
-                disposeCalls += 1;
-                if (failure === 'dispose' && fail) {
-                  throw new Error('dispose sentinel must not escape');
-                }
-                if (failure === 'primary' && fail) {
-                  throw new Error('cleanup sentinel must not replace primary');
-                }
-              },
-            };
-          };
-
-          const refusal = await bakeFont(ttfPath, outDir, factory).catch((error) => error);
-          expect(refusal).toBeInstanceOf(FontError);
-          expect(refusal).toMatchObject({
-            code: 'bake-failed',
-            expected: expect.stringContaining('generator'),
-            hint: expect.stringContaining('generator'),
-            detail: { cause: expect.any(String) },
-          });
-          const cause = (refusal as FontError).detail?.cause;
-          expect(typeof cause).toBe('string');
-          expect((cause as string).length).toBeLessThan(256);
-          if (failure === 'dispose') {
-            expect(cause).toContain('dispose');
-          } else {
-            expect(cause).toBe('primary generator failure');
-            expect(cause).not.toContain('cleanup sentinel');
-          }
-          expect('atlasPath' in (refusal as object)).toBe(false);
-          await expect(stat(atlasPath)).rejects.toMatchObject({ code: 'ENOENT' });
-          await expect(stat(sidecarPath)).rejects.toMatchObject({ code: 'ENOENT' });
-          expect(factoryCalls).toBe(1);
-          expect(generateCalls).toBe(1);
-          expect(disposeCalls).toBe(1);
-
-          fail = false;
-          const repaired = await bakeFont(ttfPath, outDir, factory);
-          const repairedAtlasBytes = await readFile(repaired.atlasPath);
-          const repairedSidecar = await readFile(repaired.sidecarPath, 'utf8');
-          expect(repaired).toEqual({ atlasPath, sidecarPath });
-          expect(factoryCalls).toBe(2);
-          expect(generateCalls).toBe(2);
-          expect(disposeCalls).toBe(2);
-
-          const repeated = await bakeFont(ttfPath, outDir, factory);
-          expect(repeated).toEqual(repaired);
-          expect(await readFile(repeated.atlasPath)).toEqual(repairedAtlasBytes);
-          expect(await readFile(repeated.sidecarPath, 'utf8')).toBe(repairedSidecar);
-          expect(factoryCalls).toBe(3);
-          expect(generateCalls).toBe(3);
-          expect(disposeCalls).toBe(3);
-        }
-      });
-
-      it('(e) unreadable source yields structured bake-failed before generator or output work', async () => {
-        const ttfPath = join(tmpRoot, 'missing-source.ttf');
-        const outDir = join(tmpRoot, 'untouched-output');
-        let factoryCalls = 0;
-        let generateCalls = 0;
-        let disposeCalls = 0;
-        const factory = async (): Promise<MsdfGenerator> => {
-          factoryCalls += 1;
-          return {
-            generateAtlas: async () => {
-              generateCalls += 1;
-              return {} as BakeAtlas;
-            },
-            dispose: async () => {
-              disposeCalls += 1;
-            },
-          };
-        };
-
-        const error = await bakeFont(ttfPath, outDir, factory).catch((e) => e);
-        expect(error).toBeInstanceOf(FontError);
-        expect(error).toMatchObject({
-          code: 'bake-failed',
-          expected: expect.stringContaining('readable'),
-          hint: expect.stringContaining('source'),
-        });
-        expect((error as FontError).detail).toMatchObject({
-          path: ttfPath,
-          cause: expect.stringContaining('ENOENT'),
-        });
-        expect(factoryCalls).toBe(0);
-        expect(generateCalls).toBe(0);
-        expect(disposeCalls).toBe(0);
-        await expect(stat(outDir)).rejects.toMatchObject({ code: 'ENOENT' });
-      });
-
-      it('(e) repairs the same source path and repeats deterministic output with balanced disposal', async () => {
-        const ttfPath = join(tmpRoot, 'repair-in-place.ttf');
-        const outDir = join(tmpRoot, 'repair-output');
-        let factoryCalls = 0;
-        let generateCalls = 0;
-        let disposeCalls = 0;
-        const factory = async (): Promise<MsdfGenerator> => {
-          factoryCalls += 1;
-          return {
-            generateAtlas: async (bytes) => {
-              generateCalls += 1;
-              expect(bytes.slice(0, TTF_MAGIC.length)).toEqual(TTF_MAGIC);
-              return {
-                texture: { width: 2, height: 2, data: new Uint8Array(16) },
-                glyphs: [
-                  {
-                    unicode: 65,
-                    advance: 10,
-                    xoffset: 1,
-                    yoffset: 2,
-                    atlasPosition: [0, 0],
-                    atlasSize: [1, 1],
-                  },
-                ],
-                metrics: { lineHeight: 20, ascender: 16 },
-                textureSize: [2, 2],
-                fieldRange: 4,
-              };
-            },
-            dispose: async () => {
-              disposeCalls += 1;
-            },
-          };
-        };
-
-        const missing = await bakeFont(ttfPath, outDir, factory).catch((e) => e);
-        expect(missing).toBeInstanceOf(FontError);
-        expect((missing as FontError).code).toBe('bake-failed');
-        expect(factoryCalls).toBe(0);
-        expect(generateCalls).toBe(0);
-        expect(disposeCalls).toBe(0);
-
-        await writeFile(ttfPath, TTF_MAGIC);
-        const first = await bakeFont(ttfPath, outDir, factory);
-        const firstPng = await readFile(first.atlasPath);
-        const firstSidecar = await readFile(first.sidecarPath, 'utf8');
-
-        const second = await bakeFont(ttfPath, outDir, factory);
-        const secondPng = await readFile(second.atlasPath);
-        const secondSidecar = await readFile(second.sidecarPath, 'utf8');
-
-        expect(first).toEqual({
-          atlasPath: join(outDir, 'repair-in-place.atlas.png'),
-          sidecarPath: join(outDir, 'repair-in-place.meta.json'),
-        });
-        expect(second).toEqual(first);
-        expect(secondPng).toEqual(firstPng);
-        expect(secondSidecar).toBe(firstSidecar);
-        expect(factoryCalls).toBe(2);
-        expect(generateCalls).toBe(2);
-        expect(disposeCalls).toBe(2);
-      });
     });
   });
 }
@@ -840,6 +193,8 @@ describe('font package root surface', () => {
     expect('FONT_PACKAGE_VERSION' in mod).toBe(false);
     expect(typeof mod.fontContribution).toBe('object');
     expect('bakeFont' in mod).toBe(false);
+    expect('encodePng' in mod).toBe(false);
+    expect('atlasToSidecar' in mod).toBe(false);
     expect('runCliFont' in mod).toBe(false);
   });
 });