refactor(fonts): extract via documents.js's extractSourceFontsForFormat

The format-to-FontSourcePackage dispatch (docx/pptx via ooxml.js's
decodePackage, odt/odp/ods/odg via odf.js's) now lives in documents.js's
own extractSourceFontsForFormat, which rejects an unsupported format
(xlsx/pdf/markdown/odf) by throwing UnsupportedFontSourceFormatError
rather than a plain Error -- mapped here to EXIT_USAGE_ERROR, matching
this CLI's existing exit-code convention for a bad invocation choice.
Format validation now happens after the input bytes are read (inside
extractSourceFontsForFormat itself) rather than before, so the
unsupported-format rejection test needs a real (if trivial) input file
instead of a path that was never actually opened.

Author: Mearman

src/commands/fonts.test.ts

@@ -50,6 +50,8 @@ beforeAll(async () => {
   const plain = createDocx();
   plain.body.appendParagraph().appendRun({ text: 'No fonts embedded here.' });
   await writeFile(join(workspace, 'plain.docx'), plain.toBytes());
+  // extractSourceFontsForFormat (documents.js) validates the format itself rather than the CLI pre-checking it, so the input file is now genuinely read before that rejection fires -- unlike a bare nonexistent path, this needs to exist. Its content is never parsed: the rejection below fires purely on the '.xlsx' extension.
+  await writeFile(join(workspace, 'unused.xlsx'), new Uint8Array([0]));
 });
 
 afterAll(async () => {
@@ -106,7 +108,7 @@ describe('fonts', () => {
   });
 
   it('rejects a format with no source-embedded-font concept, naming the restriction', async () => {
-    const { exitCode, stderr } = await runCli(['fonts', 'unused.xlsx']);
+    const { exitCode, stderr } = await runCli(['fonts', join(workspace, 'unused.xlsx')]);
 
     expect(exitCode).toBe(EXIT_USAGE_ERROR);
     expect(stderr).toContain('xlsx');

src/commands/fonts.ts

@@ -1,6 +1,5 @@
 import { type Command } from 'commander';
-import { decodePackage, extractSourceFonts, type DocumentFormat, type FontSourcePackage } from 'documents.js';
-import { decodePackage as decodeOdfPackage } from 'odf.js';
+import { extractSourceFontsForFormat } from 'documents.js';
 import { inferFormatFromExtension } from '../format';
 import { createRuntimeSignal } from '../runtime/abort';
 import { EXIT_SUCCESS, EXIT_USAGE_ERROR, mapErrorToExit } from '../runtime/exit-codes';
@@ -11,28 +10,6 @@ interface FontsCliOptions {
   readonly json: boolean;
 }
 
-// The only formats `extractSourceFonts` (documents.js's `src/fonts/registry.ts`) knows how to read a source-embedded face from at all: docx/pptx via OOXML's own fontTable.xml/embeddedFontLst, odt/odp/ods/odg via ODF's own office:font-face-decls. xlsx has no OOXML font-embedding vocabulary of its own; pdf/markdown carry no source-package concept to embed a font declaration in; a standalone .odf formula document embeds only the STIX Two Math font pdf-codec itself carries, never a caller-resolvable face; .odb has no font concept at all.
-const FONT_SOURCE_FORMATS: Readonly<Record<'docx' | 'pptx' | 'odt' | 'odp' | 'ods' | 'odg', true>> = {
-  docx: true,
-  pptx: true,
-  odt: true,
-  odp: true,
-  ods: true,
-  odg: true,
-};
-
-function isFontSourceFormat(format: DocumentFormat): format is keyof typeof FONT_SOURCE_FORMATS {
-  return format in FONT_SOURCE_FORMATS;
-}
-
-// docx/pptx dispatch through ooxml.js's own decodePackage (re-exported from documents.js under its own name); odt/odp/ods/odg dispatch through odf.js's decodePackage instead, aliased on import exactly as commands/odb.ts already does to avoid the naming collision between the two same-named functions.
-function resolveFontSourcePackage(format: keyof typeof FONT_SOURCE_FORMATS, bytes: Uint8Array<ArrayBuffer>): FontSourcePackage {
-  if (format === 'docx' || format === 'pptx') {
-    return { kind: format, package: decodePackage(bytes) };
-  }
-  return { kind: 'odf', package: decodeOdfPackage(bytes) };
-}
-
 // ProvidedFont (pdf-codec, re-exported by documents.js) carries `bytes` directly, with no `byteLength` field of its own -- computed here rather than exposing the raw font bytes themselves, which no caller of this command's summary output has asked for and which would bloat --json output by however large the embedded face is.
 interface FontFaceSummary {
   readonly family: string;
@@ -51,14 +28,10 @@ async function runFonts(input: string, options: FontsCliOptions): Promise<number
       process.stderr.write(`[${command}] cannot infer a document format from '${input}'; expected one of docx, pptx, odt, odp, ods, odg\n`);
       return EXIT_USAGE_ERROR;
     }
-    if (!isFontSourceFormat(format)) {
-      process.stderr.write(`[${command}] '${format}' documents carry no source-embedded font faces this command can extract; expected one of docx, pptx, odt, odp, ods, odg\n`);
-      return EXIT_USAGE_ERROR;
-    }
 
     const inputBytes = await readInput(input, { signal });
-    const source = resolveFontSourcePackage(format, new Uint8Array(inputBytes));
-    const faces = extractSourceFonts(source);
+    // extractSourceFontsForFormat itself rejects a format with no source-embedded font concept (xlsx, pdf, markdown, odf), naming the six it supports -- no separate isFontSourceFormat guard needed here any more.
+    const faces = extractSourceFontsForFormat(format, new Uint8Array(inputBytes));
     const summaries: readonly FontFaceSummary[] = faces.map((face) => ({ family: face.family, bold: face.bold, italic: face.italic, byteLength: face.bytes.length }));
 
     if (options.json) {

src/runtime/exit-codes.ts

@@ -10,6 +10,7 @@ import {
   OdmUnresolvedSectionError,
   PdfEncryptedError,
   PdfParseError,
+  UnsupportedFontSourceFormatError,
 } from 'documents.js';
 
 // Mirrors sysexits.h-style convention loosely: 0 is success, 1 is a generic failure, 2 is a usage error (matching coreutils' own convention for bad invocation), and the two signal-derived codes (124, 130) match `timeout(1)` and 128+SIGINT respectively, so a caller scripting against this CLI sees the same exit codes it would from any other well-behaved Unix tool.
@@ -43,6 +44,10 @@ export function mapErrorToExit(error: unknown, abortReason: 'interrupt' | 'timeo
   if (error instanceof HsqldbSqlUnsupportedError || error instanceof HsqldbSqlParseError || error instanceof HsqldbSqlEvaluationError) {
     return EXIT_INPUT_ERROR;
   }
+  // fonts' own extractSourceFontsForFormat: the given DocumentFormat is a real, recognised format, but not one with a source-embedded-font concept at all (xlsx, pdf, markdown, odf) -- a bad invocation choice, not an unusable file, so this maps like every other usage error rather than EXIT_INPUT_ERROR's "the file itself is the problem".
+  if (error instanceof UnsupportedFontSourceFormatError) {
+    return EXIT_USAGE_ERROR;
+  }
   // PdfEncryptedError extends PdfParseError, so this branch is redundant with the default fall-through below -- kept explicit anyway so the mapping documents its intent (these two error classes are unusable-input failures, not a catch-all) rather than relying on an implicit default to cover a case this function is specifically supposed to name.
   if (error instanceof PdfEncryptedError || error instanceof PdfParseError) {
     return EXIT_INPUT_ERROR;