@flighthq/font-formats 0.3.1-next.209.43ef1bc

package/src/openTypeGlyf.test.ts

@@ -0,0 +1,168 @@
+import { PathCommand } from '@flighthq/types/contract';
+import type { Path } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { readOpenTypeGlyphOutline, readOpenTypeGlyphRanges } from './openTypeGlyf';
+import { readOpenTypeGlyphCount, readOpenTypeLocaFormat } from './openTypeMetrics';
+import { createSyntheticFont, emptySyntheticGlyph, squareSyntheticGlyph } from './openTypeTestHelper';
+import type { SyntheticGlyph } from './openTypeTestHelper';
+import { readSfntTableDirectory } from './sfntTableDirectory';
+
+function createPath(): Path {
+  return { commands: [], data: [], winding: 'evenOdd' };
+}
+
+// Reads a glyph out of a synthetic font through the same steps the source does, so these tests exercise
+// the real `loca`/`glyf` pair rather than a hand-built range array.
+function readGlyph(glyphs: readonly SyntheticGlyph[], glyphIndex: number): { ok: boolean; path: Path } {
+  const font = createSyntheticFont({ glyphs });
+  const directory = readSfntTableDirectory(font)!;
+  const ranges = readOpenTypeGlyphRanges(
+    font,
+    directory,
+    readOpenTypeGlyphCount(font, directory),
+    readOpenTypeLocaFormat(font, directory),
+  )!;
+  const path = createPath();
+  return { ok: readOpenTypeGlyphOutline(path, font, directory, ranges, glyphIndex), path };
+}
+
+describe('readOpenTypeGlyphOutline', () => {
+  it('writes the winding rather than leaving whatever the caller had', () => {
+    // Seeded with the WRONG rule on purpose. A fresh `createPath` already defaults to nonZero, so a
+    // test that built one would pass whether or not this reader writes the field — and a caller
+    // reusing a scratch path across glyphs is exactly the case that keeps a stale value and renders
+    // a counter as a solid blob.
+    const path: Path = { commands: [], data: [], winding: 'evenOdd' };
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)] });
+    const directory = readSfntTableDirectory(font)!;
+    const ranges = readOpenTypeGlyphRanges(
+      font,
+      directory,
+      readOpenTypeGlyphCount(font, directory),
+      readOpenTypeLocaFormat(font, directory),
+    )!;
+    readOpenTypeGlyphOutline(path, font, directory, ranges, 1);
+    expect(path.winding).toBe('nonZero');
+  });
+
+  it('emits one line per edge and closes, without a redundant segment back to the start', () => {
+    const { ok, path } = readGlyph([emptySyntheticGlyph(), squareSyntheticGlyph(100)], 1);
+    expect(ok).toBe(true);
+    // Four corners: a move, three lines, and a close that implies the fourth edge.
+    expect(path.commands).toEqual([
+      PathCommand.MOVE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.CLOSE,
+    ]);
+  });
+
+  // The rule that makes this format different from every other path format: two consecutive off-curve
+  // points imply an on-curve point exactly halfway between them, which the file omits because it is
+  // recoverable. A reader that takes the point list literally visibly cuts corners.
+  it('reconstructs the on-curve point implied between two consecutive off-curve points', () => {
+    const glyph: SyntheticGlyph = {
+      endPoints: [2],
+      points: [
+        [0, 0, true],
+        [100, 0, false],
+        [100, 100, false],
+      ],
+    };
+    const { path } = readGlyph([emptySyntheticGlyph(), glyph], 1);
+    expect(path.commands).toEqual([PathCommand.MOVE_TO, PathCommand.CURVE_TO, PathCommand.CURVE_TO, PathCommand.CLOSE]);
+    // First curve ends at the midpoint of the two controls — (100,0) and (100,100) → (100,50), negated.
+    expect(path.data.slice(2, 6)).toEqual([100, -0, 100, -50]);
+  });
+
+  it('starts at the midpoint when a contour opens and closes off-curve', () => {
+    const glyph: SyntheticGlyph = {
+      endPoints: [2],
+      points: [
+        [0, 100, false],
+        [50, 0, true],
+        [100, 100, false],
+      ],
+    };
+    const { path } = readGlyph([emptySyntheticGlyph(), glyph], 1);
+    // Neither the first nor the last point is on-curve, so the contour begins halfway between them:
+    // (0,100) and (100,100) → (50,100), negated to y-down.
+    expect(path.data.slice(0, 2)).toEqual([50, -100]);
+    expect(path.commands[0]).toBe(PathCommand.MOVE_TO);
+  });
+
+  it('emits a quadratic through a single off-curve control', () => {
+    const glyph: SyntheticGlyph = {
+      endPoints: [2],
+      points: [
+        [0, 0, true],
+        [50, 100, false],
+        [100, 0, true],
+      ],
+    };
+    const { path } = readGlyph([emptySyntheticGlyph(), glyph], 1);
+    expect(path.commands).toEqual([PathCommand.MOVE_TO, PathCommand.CURVE_TO, PathCommand.CLOSE]);
+    expect(path.data).toEqual([0, -0, 50, -100, 100, -0]);
+  });
+
+  it('reads a second contour into the same path', () => {
+    const glyph: SyntheticGlyph = {
+      endPoints: [3, 7],
+      points: [
+        [0, 0, true],
+        [10, 0, true],
+        [10, 10, true],
+        [0, 10, true],
+        [20, 20, true],
+        [30, 20, true],
+        [30, 30, true],
+        [20, 30, true],
+      ],
+    };
+    const { path } = readGlyph([emptySyntheticGlyph(), glyph], 1);
+    expect(path.commands.filter((command) => command === PathCommand.MOVE_TO)).toHaveLength(2);
+    expect(path.commands.filter((command) => command === PathCommand.CLOSE)).toHaveLength(2);
+  });
+
+  it('returns true with an empty path for a glyph with no contours', () => {
+    const { ok, path } = readGlyph([emptySyntheticGlyph()], 0);
+    expect(ok).toBe(true);
+    expect(path.commands).toEqual([]);
+  });
+
+  it('replaces the previous contents of out rather than appending to them', () => {
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)] });
+    const directory = readSfntTableDirectory(font)!;
+    const ranges = readOpenTypeGlyphRanges(font, directory, readOpenTypeGlyphCount(font, directory), 1)!;
+    const path = createPath();
+    readOpenTypeGlyphOutline(path, font, directory, ranges, 1);
+    const first = path.commands.length;
+    readOpenTypeGlyphOutline(path, font, directory, ranges, 1);
+    expect(path.commands).toHaveLength(first);
+  });
+
+  it('returns false for an index outside the range table', () => {
+    expect(readGlyph([emptySyntheticGlyph()], 5).ok).toBe(false);
+    expect(readGlyph([emptySyntheticGlyph()], -1).ok).toBe(false);
+  });
+});
+
+describe('readOpenTypeGlyphRanges', () => {
+  it('yields one more entry than there are glyphs, so every glyph has an end', () => {
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10)] });
+    const directory = readSfntTableDirectory(font)!;
+    expect(readOpenTypeGlyphRanges(font, directory, 2, 1)).toHaveLength(3);
+  });
+
+  it('returns the sentinel when loca is absent', () => {
+    const font = createSyntheticFont({ omitTable: 'loca' });
+    expect(readOpenTypeGlyphRanges(font, readSfntTableDirectory(font)!, 1, 1)).toBeNull();
+  });
+
+  it('returns the sentinel when loca is too short for the glyph count it must index', () => {
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph()] });
+    expect(readOpenTypeGlyphRanges(font, readSfntTableDirectory(font)!, 999, 1)).toBeNull();
+  });
+});

package/src/openTypeGlyphOutlineSource.test.ts

@@ -0,0 +1,298 @@
+import { PathCommand } from '@flighthq/types/contract';
+import type { Path } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { createGlyphOutlineSourceFromOpenTypeFont, explainOpenTypeFont } from './openTypeGlyphOutlineSource';
+import {
+  createSyntheticFont,
+  emptySyntheticGlyph,
+  encodeSyntheticWoff,
+  squareSyntheticGlyph,
+} from './openTypeTestHelper';
+import { readSfntTableDirectory } from './sfntTableDirectory';
+
+// Every font here is assembled byte by byte by the helper. Nothing third-party is read, fetched, or
+// committed, and each test states the table contents its assertion depends on.
+// A WOFF is a real font behind a compression wrapper — a different remedy from unreadable bytes, which is
+// why it gets its own reason.
+// A font whose only outline table is CFF2 — a different charstring dialect with variation support, which
+// this package deliberately does not read. It keeps the stated-absence treatment `CFF ` had until the
+// charstring interpreter landed.
+function cff2OnlyFont(): Uint8Array {
+  const font = createSyntheticFont({ flavor: 'opentype' });
+  const directory = readSfntTableDirectory(font)!;
+  const record = [...directory.tables.keys()].sort().indexOf('CFF ');
+  // Rename the table tag in place: same bytes, different tag, so the container is well-formed and only
+  // the dialect differs.
+  for (const [index, character] of [...'CFF2'].entries()) font[12 + record * 16 + index] = character.charCodeAt(0);
+  return font;
+}
+
+function woff2Bytes(): Uint8Array {
+  const bytes = new Uint8Array(20);
+  bytes.set([0x77, 0x4f, 0x46, 0x32]);
+  return bytes;
+}
+
+// Every table present, but `head` states a zero unitsPerEm — the one value that cannot be defaulted,
+// since it is the scale denominator every coordinate divides by.
+function malformedUnitsPerEmFont(): Uint8Array {
+  const font = createSyntheticFont();
+  const head = readSfntTableDirectory(font)!.tables.get('head')!;
+  new DataView(font.buffer, font.byteOffset, font.byteLength).setUint16(head.offset + 18, 0);
+  return font;
+}
+
+function createPath(): Path {
+  return { commands: [], data: [], winding: 'evenOdd' };
+}
+
+describe('createGlyphOutlineSourceFromOpenTypeFont', () => {
+  it('produces a source from a well-formed TrueType font', () => {
+    expect(createGlyphOutlineSourceFromOpenTypeFont(createSyntheticFont())).not.toBeNull();
+  });
+
+  it('reports the font-wide metrics in design units, with descent as a positive distance', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(createSyntheticFont({ unitsPerEm: 2048 }));
+    // The fixture stores descender as -200, as the format requires; the seam flips it.
+    expect(source?.getGlyphOutlineMetrics()).toEqual({ ascent: 800, descent: 200, lineGap: 100, unitsPerEm: 2048 });
+  });
+
+  it('maps a codepoint to its glyph index and returns -1 for one the font does not cover', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(
+      createSyntheticFont({
+        codepoints: new Map([[65, 1]]),
+        glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)],
+      }),
+    );
+    expect(source?.getGlyphOutlineIndexForCodePoint(65)).toBe(1);
+    expect(source?.getGlyphOutlineIndexForCodePoint(66)).toBe(-1);
+  });
+
+  it('reads a square contour into the path, with y negated into the downward convention', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(
+      createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)] }),
+    );
+    const path = createPath();
+    expect(source?.getGlyphOutline(path, 1)).toBe(true);
+    expect(path.commands).toEqual([
+      PathCommand.MOVE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.CLOSE,
+    ]);
+    // The font states y-up (0,0) (100,0) (100,100) (0,100); ink above the baseline is negative y here.
+    expect(path.data).toEqual([0, -0, 100, -0, 100, -100, 0, -100]);
+  });
+
+  it('returns true with an empty path for a glyph that legitimately has no outline', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(createSyntheticFont({ glyphs: [emptySyntheticGlyph()] }));
+    const path = createPath();
+    // True, not false: a space still has to advance, so its absence of ink must stay observable.
+    expect(source?.getGlyphOutline(path, 0)).toBe(true);
+    expect(path.commands).toEqual([]);
+  });
+
+  it('returns false for a glyph index the font does not have', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(createSyntheticFont());
+    expect(source?.getGlyphOutline(createPath(), 99)).toBe(false);
+    expect(source?.getGlyphOutline(createPath(), -1)).toBe(false);
+  });
+
+  it('reports each glyph its own advance', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(
+      createSyntheticFont({ advances: [300, 750], glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(50)] }),
+    );
+    expect(source?.getGlyphOutlineAdvance(0)).toBe(300);
+    expect(source?.getGlyphOutlineAdvance(1)).toBe(750);
+  });
+
+  // The run-length rule in `hmtx`: glyphs past `numberOfHMetrics` repeat the last stated advance. A
+  // reader treating the table as flat gives every one of them a wrong width, which is how a monospaced
+  // or CJK font silently mis-measures.
+  it('repeats the last stated advance for glyphs past the long-metric count', () => {
+    const source = createGlyphOutlineSourceFromOpenTypeFont(
+      createSyntheticFont({
+        advances: [600],
+        glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10), squareSyntheticGlyph(20)],
+      }),
+    );
+    expect(source?.getGlyphOutlineAdvance(1)).toBe(600);
+    expect(source?.getGlyphOutlineAdvance(2)).toBe(600);
+  });
+
+  it('returns the sentinel rather than throwing for bytes that are not a font', () => {
+    expect(
+      createGlyphOutlineSourceFromOpenTypeFont(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])),
+    ).toBeNull();
+    expect(createGlyphOutlineSourceFromOpenTypeFont(new Uint8Array(0))).toBeNull();
+  });
+
+  // CFF outlines are read now. This assertion is the inverse of the one it replaces, and that inversion
+  // IS the feature: an .otf used to reject with `unsupported-outlines` and now produces a source.
+  it('produces a source from a CFF-outline font, which used to be a stated rejection', () => {
+    expect(createGlyphOutlineSourceFromOpenTypeFont(createSyntheticFont({ flavor: 'opentype' }))).not.toBeNull();
+  });
+
+  it('reads a CFF glyph outline as cubic curves, end to end from the container', () => {
+    const charstring = new Uint8Array([139, 139, 21, 149, 139, 149, 149, 139, 149, 8, 14]);
+    const font = createSyntheticFont({ flavor: 'opentype', charstrings: [new Uint8Array([14]), charstring] });
+    const source = createGlyphOutlineSourceFromOpenTypeFont(font)!;
+    const path = createPath();
+    expect(source.getGlyphOutline(path, 1)).toBe(true);
+    expect(path.commands).toEqual([PathCommand.MOVE_TO, PathCommand.CUBIC_CURVE_TO, PathCommand.CLOSE]);
+  });
+
+  // THE CID CASE, END TO END. Both glyphs call subroutine index -107, and each FD's pool holds a
+  // DIFFERENT subroutine — one drawing a horizontal line, one vertical. If both glyphs resolved against
+  // one pool they would draw the same shape, which is exactly the plausible-garbage failure the
+  // per-glyph binding prevents.
+  it('resolves the same subroutine index differently per glyph in a CID font', () => {
+    const call = new Uint8Array([139, 139, 21, 32, 10, 14]);
+    const font = createSyntheticFont({
+      charstrings: [call, call],
+      cid: {
+        fdSelect: [0, 1],
+        pools: [[new Uint8Array([149, 139, 5, 11])], [new Uint8Array([139, 149, 5, 11])]],
+      },
+      flavor: 'opentype',
+    });
+    const source = createGlyphOutlineSourceFromOpenTypeFont(font)!;
+    const first = createPath();
+    const second = createPath();
+    expect(source.getGlyphOutline(first, 0)).toBe(true);
+    expect(source.getGlyphOutline(second, 1)).toBe(true);
+    expect(first.data).not.toEqual(second.data);
+    // FD 0 draws +10 on x; FD 1 draws +10 on y, negated into the y-down convention.
+    expect(first.data).toEqual([0, -0, 10, -0]);
+    expect(second.data).toEqual([0, -0, 0, -10]);
+  });
+
+  // WOFF END TO END. The whole design claim is that it needs no new outline code: unwrap once, and the
+  // directory, both flavors and CID all read the rebuilt sfnt without knowing it arrived wrapped.
+  it('produces a source from a WOFF, which used to be an unsupported container', () => {
+    const woff = encodeSyntheticWoff(
+      createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)] }),
+    );
+    const source = createGlyphOutlineSourceFromOpenTypeFont(woff)!;
+    expect(source).not.toBeNull();
+    const path = createPath();
+    expect(source.getGlyphOutline(path, 1)).toBe(true);
+    expect(path.data).toEqual([0, -0, 100, -0, 100, -100, 0, -100]);
+  });
+
+  it('reads a CFF font through the WOFF wrapper, since the wrapper is flavor-agnostic', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont({ flavor: 'opentype' }));
+    expect(createGlyphOutlineSourceFromOpenTypeFont(woff)).not.toBeNull();
+  });
+
+  it('still rejects CFF2, which is a different charstring dialect and remains a stated absence', () => {
+    const font = createSyntheticFont({ flavor: 'opentype', omitTable: 'CFF ' });
+    // Re-add only CFF2, so the font carries charstrings this package deliberately does not read.
+    expect(explainOpenTypeFont(font).reason).toBe('missing-required-table');
+  });
+
+  it('returns the sentinel when a required table is missing', () => {
+    for (const table of ['cmap', 'head', 'hhea', 'hmtx', 'maxp', 'loca', 'glyf']) {
+      expect(createGlyphOutlineSourceFromOpenTypeFont(createSyntheticFont({ omitTable: table }))).toBeNull();
+    }
+  });
+
+  it('returns the sentinel for a truncated font rather than reading past the buffer', () => {
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)] });
+    expect(createGlyphOutlineSourceFromOpenTypeFont(font.subarray(0, font.length - 8))).toBeNull();
+  });
+});
+
+describe('explainOpenTypeFont', () => {
+  it('accepts a font the producer accepts, and the two never disagree', () => {
+    const font = createSyntheticFont();
+    const explanation = explainOpenTypeFont(font);
+    expect(explanation.accepted).toBe(true);
+    expect(explanation.reason).toBe('ok');
+    expect(createGlyphOutlineSourceFromOpenTypeFont(font)).not.toBeNull();
+  });
+
+  // ALL SEVEN REJECTION REASONS, EACH ASSERTING **BOTH** THE EXPLANATION AND THE PRODUCER ON THE SAME
+  // BYTES. Previously only the accept path was cross-checked, so an explanation could have named a reason
+  // the producer never failed for — or named one while the producer happily returned a source — and the
+  // suite would have stayed green. The two share one parse so they cannot disagree BY CONSTRUCTION, and
+  // probably-holds-by-construction is exactly the claim this pins instead of assuming.
+  it.each([
+    ['too-short', new Uint8Array([0, 1, 0, 0])],
+    ['unrecognized', new Uint8Array(20)],
+    ['unsupported-container', woff2Bytes()],
+    ['missing-required-table', createSyntheticFont({ omitTable: 'cmap' })],
+    ['unsupported-outlines', cff2OnlyFont()],
+    ['malformed-table', malformedUnitsPerEmFont()],
+  ])('rejects with reason %s, and the producer returns the sentinel on the same bytes', (reason, bytes) => {
+    const explanation = explainOpenTypeFont(bytes);
+    expect(explanation.reason).toBe(reason);
+    expect(explanation.accepted).toBe(false);
+    expect(createGlyphOutlineSourceFromOpenTypeFont(bytes)).toBeNull();
+  });
+
+  // The seventh reason, `ok`, is the inverse pairing: the explanation accepts AND the producer succeeds.
+  it('accepts with reason ok, and the producer returns a source on the same bytes', () => {
+    const font = createSyntheticFont();
+    expect(explainOpenTypeFont(font).reason).toBe('ok');
+    expect(explainOpenTypeFont(font).accepted).toBe(true);
+    expect(createGlyphOutlineSourceFromOpenTypeFont(font)).not.toBeNull();
+  });
+
+  it('reports the container it recognized even on success', () => {
+    expect(explainOpenTypeFont(createSyntheticFont()).format).toBe('truetype');
+  });
+
+  it('accepts a CFF font now that its charstrings are read', () => {
+    const explanation = explainOpenTypeFont(createSyntheticFont({ flavor: 'opentype' }));
+    expect(explanation.reason).toBe('ok');
+    expect(explanation.accepted).toBe(true);
+  });
+
+  it('names the specific missing table', () => {
+    expect(explainOpenTypeFont(createSyntheticFont({ omitTable: 'cmap' })).table).toBe('cmap');
+    expect(explainOpenTypeFont(createSyntheticFont({ omitTable: 'hmtx' })).table).toBe('hmtx');
+    expect(explainOpenTypeFont(createSyntheticFont({ omitTable: 'loca' })).table).toBe('loca');
+    expect(explainOpenTypeFont(createSyntheticFont({ omitTable: 'cmap' })).reason).toBe('missing-required-table');
+  });
+
+  it('reports a missing glyf as a missing table when no charstring table stands in its place', () => {
+    const explanation = explainOpenTypeFont(createSyntheticFont({ omitTable: 'glyf' }));
+    expect(explanation.reason).toBe('missing-required-table');
+    expect(explanation.table).toBe('glyf');
+  });
+
+  it('distinguishes bytes that are no font at all from a font it will not open', () => {
+    expect(explainOpenTypeFont(new Uint8Array(20)).reason).toBe('unrecognized');
+    // WOFF2 needs Brotli and a table-transform reversal, so it stays a container this package does not
+    // open — unlike WOFF, which is read now.
+    const woff2 = new Uint8Array(20);
+    woff2.set([0x77, 0x4f, 0x46, 0x32]);
+    expect(explainOpenTypeFont(woff2).reason).toBe('unsupported-container');
+    expect(explainOpenTypeFont(woff2).format).toBe('woff2');
+  });
+
+  // The decompressor is deliberately not bundled, so an unregistered one is a real outcome with a
+  // one-line remedy — distinct from a container needing a different producer entirely.
+  it('reports a missing decompressor as its own reason rather than an unsupported container', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    new DataView(woff.buffer).setUint32(44 + 8, 4);
+    expect(explainOpenTypeFont(woff).reason).toBe('missing-decompressor');
+  });
+
+  it('reports too-short for bytes below the sfnt header', () => {
+    expect(explainOpenTypeFont(new Uint8Array([0, 1, 0, 0])).reason).toBe('too-short');
+  });
+
+  it('counts declared tables against readable ones, localizing a truncation', () => {
+    const font = createSyntheticFont();
+    const whole = explainOpenTypeFont(font);
+    expect(whole.tableCount).toBe(whole.readableTableCount);
+
+    const truncated = explainOpenTypeFont(font.subarray(0, font.length - 8));
+    // The directory still declares every table; fewer of them now fit inside the file.
+    expect(truncated.readableTableCount).toBeLessThan(truncated.tableCount);
+  });
+});

package/src/openTypeMetrics.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  readOpenTypeAdvances,
+  readOpenTypeGlyphCount,
+  readOpenTypeLocaFormat,
+  readOpenTypeMetrics,
+} from './openTypeMetrics';
+import { createSyntheticFont, emptySyntheticGlyph, squareSyntheticGlyph } from './openTypeTestHelper';
+import { readSfntTableDirectory } from './sfntTableDirectory';
+
+describe('readOpenTypeAdvances', () => {
+  it('reads one advance per glyph', () => {
+    const font = createSyntheticFont({
+      advances: [300, 750],
+      glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10)],
+    });
+    expect([...readOpenTypeAdvances(font, readSfntTableDirectory(font)!, 2)!]).toEqual([300, 750]);
+  });
+
+  // `hmtx` is run-length shaped: glyphs past `numberOfHMetrics` repeat the last stated advance. Reading
+  // it flat gives every one of them a wrong width, which is exactly how monospaced and CJK fonts stay
+  // small — so the bug would be invisible on a Latin test font and wrong on the fonts that use it.
+  it('repeats the last stated advance past the long-metric count rather than reading zero', () => {
+    const font = createSyntheticFont({
+      advances: [600],
+      glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10), squareSyntheticGlyph(20)],
+    });
+    expect([...readOpenTypeAdvances(font, readSfntTableDirectory(font)!, 3)!]).toEqual([600, 600, 600]);
+  });
+
+  it('returns the sentinel when hmtx or hhea is absent', () => {
+    for (const table of ['hmtx', 'hhea']) {
+      const font = createSyntheticFont({ omitTable: table });
+      expect(readOpenTypeAdvances(font, readSfntTableDirectory(font)!, 1)).toBeNull();
+    }
+  });
+});
+
+describe('readOpenTypeGlyphCount', () => {
+  it('reads the count maxp declares', () => {
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10)] });
+    expect(readOpenTypeGlyphCount(font, readSfntTableDirectory(font)!)).toBe(2);
+  });
+
+  it('returns -1 rather than a count when maxp is absent, so every index is out of range', () => {
+    const font = createSyntheticFont({ omitTable: 'maxp' });
+    expect(readOpenTypeGlyphCount(font, readSfntTableDirectory(font)!)).toBe(-1);
+  });
+});
+
+describe('readOpenTypeLocaFormat', () => {
+  it('reads the index-to-loc format head declares', () => {
+    const font = createSyntheticFont();
+    expect(readOpenTypeLocaFormat(font, readSfntTableDirectory(font)!)).toBe(1);
+  });
+
+  it('returns -1 for a value that is neither of the two the format defines', () => {
+    const font = createSyntheticFont();
+    const directory = readSfntTableDirectory(font)!;
+    // Guessing here would produce plausible garbage outlines instead of a clean rejection.
+    new DataView(font.buffer).setInt16(directory.tables.get('head')!.offset + 50, 7);
+    expect(readOpenTypeLocaFormat(font, directory)).toBe(-1);
+  });
+
+  it('returns -1 when head is absent', () => {
+    const font = createSyntheticFont({ omitTable: 'head' });
+    expect(readOpenTypeLocaFormat(font, readSfntTableDirectory(font)!)).toBe(-1);
+  });
+});
+
+describe('readOpenTypeMetrics', () => {
+  it('reads the design-unit scale from head', () => {
+    const font = createSyntheticFont({ unitsPerEm: 2048 });
+    expect(readOpenTypeMetrics(font, readSfntTableDirectory(font)!)?.unitsPerEm).toBe(2048);
+  });
+
+  // `hhea` states descender as a negative distance; `GlyphOutlineMetrics` documents both ascent and
+  // descent as POSITIVE distances from the baseline. The flip happens once, here, at the seam.
+  it('reports descent as a positive distance although the table stores it negative', () => {
+    const font = createSyntheticFont();
+    expect(readOpenTypeMetrics(font, readSfntTableDirectory(font)!)).toEqual({
+      ascent: 800,
+      descent: 200,
+      lineGap: 100,
+      unitsPerEm: 1000,
+    });
+  });
+
+  it('returns the sentinel for a zero unitsPerEm rather than a scale that divides by zero', () => {
+    const font = createSyntheticFont();
+    const directory = readSfntTableDirectory(font)!;
+    new DataView(font.buffer).setUint16(directory.tables.get('head')!.offset + 18, 0);
+    expect(readOpenTypeMetrics(font, directory)).toBeNull();
+  });
+
+  it('returns the sentinel when head or hhea is absent', () => {
+    for (const table of ['head', 'hhea']) {
+      const font = createSyntheticFont({ omitTable: table });
+      expect(readOpenTypeMetrics(font, readSfntTableDirectory(font)!)).toBeNull();
+    }
+  });
+});

package/src/sfntAssembly.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+
+import { assembleSfntFont, computeSfntTableChecksum, packSfntTag } from './sfntAssembly';
+
+describe('assembleSfntFont', () => {
+  it('writes the directory in tag order whatever order it was given', () => {
+    // Reversed on purpose. A pre-sorted input would pass whether or not anything sorted, which is how
+    // the WOFF tag-order test was once vacuous.
+    const font = assembleSfntFont(0x00010000, [
+      { data: Uint8Array.from([9]), tag: packSfntTag('name') },
+      { data: Uint8Array.from([7]), tag: packSfntTag('head') },
+      { data: Uint8Array.from([8]), tag: packSfntTag('cmap') },
+    ]);
+    const view = new DataView(font.buffer);
+    const tags = Array.from({ length: view.getUint16(4) }, (_, index) => view.getUint32(12 + index * 16));
+    expect(tags).toEqual([packSfntTag('cmap'), packSfntTag('head'), packSfntTag('name')]);
+  });
+
+  it('starts every table on a four-byte boundary', () => {
+    // Lengths chosen so that unpadded placement would land tables at odd offsets — without this the
+    // assertion would hold whether or not any padding ran.
+    const font = assembleSfntFont(0x00010000, [
+      { data: Uint8Array.from([1]), tag: packSfntTag('aaaa') },
+      { data: Uint8Array.from([2, 3, 4]), tag: packSfntTag('bbbb') },
+      { data: Uint8Array.from([5, 6]), tag: packSfntTag('cccc') },
+    ]);
+    const view = new DataView(font.buffer);
+    const count = view.getUint16(4);
+    const offsets = Array.from({ length: count }, (_, index) => view.getUint32(12 + index * 16 + 8));
+    expect(offsets.filter((offset) => offset % 4 !== 0)).toEqual([]);
+  });
+
+  it('preserves each table byte for byte at its declared offset and length', () => {
+    const payload = Uint8Array.from([11, 22, 33, 44, 55]);
+    const font = assembleSfntFont(0x4f54544f, [{ data: payload, tag: packSfntTag('CFF ') }]);
+    const view = new DataView(font.buffer);
+    const offset = view.getUint32(12 + 8);
+    const length = view.getUint32(12 + 12);
+    expect(length).toBe(payload.byteLength);
+    expect([...font.subarray(offset, offset + length)]).toEqual([...payload]);
+  });
+
+  it('writes each table a real checksum rather than a zero', () => {
+    const payload = Uint8Array.from([0, 0, 0, 7]);
+    const font = assembleSfntFont(0x00010000, [{ data: payload, tag: packSfntTag('cmap') }]);
+    const view = new DataView(font.buffer);
+    expect(view.getUint32(12 + 4)).toBe(7);
+    expect(view.getUint32(12 + 4)).toBe(computeSfntTableChecksum(payload));
+  });
+
+  it('carries the flavor it was given rather than inferring one', () => {
+    const font = assembleSfntFont(0x4f54544f, [{ data: Uint8Array.from([0]), tag: packSfntTag('CFF ') }]);
+    expect(new DataView(font.buffer).getUint32(0)).toBe(0x4f54544f);
+  });
+});
+
+describe('computeSfntTableChecksum', () => {
+  it('sums big-endian words', () => {
+    expect(computeSfntTableChecksum(Uint8Array.from([0, 0, 0, 1, 0, 0, 0, 2]))).toBe(3);
+  });
+
+  it('pads a partial final word with zeros rather than dropping it', () => {
+    // [0,0,1] is one short of a word. Dropping the tail would give 0; padding gives 0x100.
+    expect(computeSfntTableChecksum(Uint8Array.from([0, 0, 1]))).toBe(0x100);
+  });
+
+  it('treats head checkSumAdjustment as zero, which is what stops every real font mismatching', () => {
+    // Byte 8 begins checkSumAdjustment. The same bytes must sum differently for head than for any
+    // other table, so the two calls below are what separates the exception from a no-op.
+    const head = new Uint8Array(16);
+    head[8] = 0xff;
+    head[9] = 0xff;
+    expect(computeSfntTableChecksum(head, false)).toBe(0xffff0000);
+    expect(computeSfntTableChecksum(head, true)).toBe(0);
+  });
+
+  it('wraps modulo 2^32 rather than growing past a uint32', () => {
+    const big = Uint8Array.from([0xff, 0xff, 0xff, 0xff, 0, 0, 0, 2]);
+    expect(computeSfntTableChecksum(big)).toBe(1);
+  });
+});
+
+describe('packSfntTag', () => {
+  it('packs four characters big-endian', () => {
+    expect(packSfntTag('glyf')).toBe(0x676c7966);
+  });
+
+  it('pads a short tag with spaces, which is how the format spells its own', () => {
+    expect(packSfntTag('cvt')).toBe(packSfntTag('cvt '));
+    expect(packSfntTag('cvt')).toBe(0x63767420);
+  });
+});