@forgeax/engine-font 0.1.4 → 0.1.7

package/src/cli-font.ts

@@ -225,87 +225,6 @@ export interface BakeResult {
   readonly sidecarPath: string;
 }
 
-function malformedAtlasTextureCause(atlas: BakeAtlas): string | undefined {
-  const texture = atlas.texture;
-  const textureSize = atlas.textureSize;
-  if (
-    !Number.isSafeInteger(texture.width) ||
-    texture.width <= 0 ||
-    !Number.isSafeInteger(texture.height) ||
-    texture.height <= 0
-  ) {
-    return 'malformed-atlas: texture dimensions must be positive finite integers';
-  }
-  if (
-    !Number.isSafeInteger(textureSize[0]) ||
-    textureSize[0] <= 0 ||
-    !Number.isSafeInteger(textureSize[1]) ||
-    textureSize[1] <= 0
-  ) {
-    return 'malformed-atlas: textureSize dimensions must be positive finite integers';
-  }
-  if (texture.width !== textureSize[0] || texture.height !== textureSize[1]) {
-    return 'malformed-atlas: texture dimensions must match textureSize';
-  }
-  const expectedBytes = texture.width * texture.height * 4;
-  if (!(texture.data instanceof Uint8Array) || texture.data.length !== expectedBytes) {
-    return 'malformed-atlas: RGBA data length must equal width * height * 4';
-  }
-  return undefined;
-}
-
-function malformedGlyphCause(atlas: BakeAtlas): string | undefined {
-  if (
-    !Number.isFinite(atlas.metrics.lineHeight) ||
-    !Number.isFinite(atlas.metrics.ascender) ||
-    !Number.isFinite(atlas.fieldRange)
-  ) {
-    return 'malformed-glyph: common metrics must be finite';
-  }
-
-  const [atlasWidth, atlasHeight] = atlas.textureSize;
-  const seenUnicode = new Set<number>();
-  for (let index = 0; index < atlas.glyphs.length; index += 1) {
-    const glyph = atlas.glyphs[index];
-    if (glyph === undefined) {
-      return `malformed-glyph: missing glyph record at index ${index}`;
-    }
-    if (!Number.isSafeInteger(glyph.unicode) || glyph.unicode < 0 || glyph.unicode > 0x10ffff) {
-      return `malformed-glyph: invalid unicode identity at index ${index}`;
-    }
-    if (seenUnicode.has(glyph.unicode)) {
-      return `malformed-glyph: duplicate unicode identity at index ${index}`;
-    }
-    seenUnicode.add(glyph.unicode);
-
-    if (
-      !Number.isFinite(glyph.advance) ||
-      !Number.isFinite(glyph.xoffset) ||
-      !Number.isFinite(glyph.yoffset)
-    ) {
-      return `malformed-glyph: non-finite metrics at index ${index}`;
-    }
-
-    const [x, y] = glyph.atlasPosition;
-    const [width, height] = glyph.atlasSize;
-    if (
-      !Number.isSafeInteger(x) ||
-      !Number.isSafeInteger(y) ||
-      !Number.isSafeInteger(width) ||
-      !Number.isSafeInteger(height) ||
-      x < 0 ||
-      y < 0 ||
-      width < 0 ||
-      height < 0 ||
-      x + width > atlasWidth ||
-      y + height > atlasHeight
-    ) {
-      return `malformed-glyph: atlas region out of bounds at index ${index}`;
-    }
-  }
-  return undefined;
-}
-
 /**
  * Bake an MSDF atlas + glyph-metrics sidecar from a TTF.
  *
@@ -323,17 +242,7 @@ export async function bakeFont(
   outDir: string,
   generatorFactory: () => Promise<MsdfGenerator>,
 ): Promise<BakeResult> {
-  let ttf: Buffer;
-  try {
-    ttf = await readFile(ttfPath);
-  } catch (e) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: 'a readable TrueType source file',
-      hint: 'repair the source path or filesystem access, then retry the bake',
-      detail: { path: ttfPath, cause: e instanceof Error ? e.message : String(e) },
-    });
-  }
+  const ttf = await readFile(ttfPath);
   const ttfBytes = new Uint8Array(ttf.buffer, ttf.byteOffset, ttf.byteLength);
   if (!isSupportedFontMagic(ttfBytes)) {
     throw new FontError({
@@ -344,104 +253,33 @@ export async function bakeFont(
     });
   }
 
-  try {
-    await mkdir(outDir, { recursive: true });
-  } catch (e) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: 'a writable output directory',
-      hint: 'repair the output path or filesystem access, then retry the bake',
-      detail: { path: outDir, cause: e instanceof Error ? e.message : String(e) },
-    });
-  }
-
-  let atlas: BakeAtlas | undefined;
+  let atlas: BakeAtlas;
   let generator: MsdfGenerator | undefined;
-  let primaryFailure: unknown;
-  let primaryFailed = false;
-  let disposeFailure: unknown;
-  let disposeFailed = false;
   try {
     generator = await generatorFactory();
     atlas = await generator.generateAtlas(ttfBytes);
   } catch (e) {
-    primaryFailed = true;
-    primaryFailure = e;
-  } finally {
-    if (generator !== undefined) {
-      try {
-        await generator.dispose();
-      } catch (e) {
-        disposeFailed = true;
-        disposeFailure = e;
-      }
-    }
-  }
-
-  if (primaryFailed) {
     throw new FontError({
       code: 'bake-failed',
       expected: '@zappar/msdf-generator to produce an MSDF atlas',
       hint: 'the MSDF generator threw -- a Web Worker + wasm host is required (a plain Node process reports "Worker is not defined"); run the bake in a Worker-capable environment',
-      detail: {
-        cause: primaryFailure instanceof Error ? primaryFailure.message : String(primaryFailure),
-      },
-    });
-  }
-  if (disposeFailed) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: 'the MSDF generator to dispose cleanly',
-      hint: 'repair the MSDF generator lifecycle, then retry the bake',
-      detail: {
-        cause: disposeFailure instanceof Error ? disposeFailure.message : String(disposeFailure),
-      },
-    });
-  }
-  if (atlas === undefined) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: '@zappar/msdf-generator to produce an MSDF atlas',
-      hint: 'repair the MSDF generator lifecycle, then retry the bake',
-      detail: { cause: 'the MSDF generator produced no atlas' },
+      detail: { cause: e instanceof Error ? e.message : String(e) },
     });
+  } finally {
+    if (generator !== undefined) {
+      await generator.dispose().catch(() => undefined);
+    }
   }
 
+  await mkdir(outDir, { recursive: true });
   const base = basename(ttfPath, extname(ttfPath));
   const atlasName = `${base}.atlas.png`;
   const atlasPath = join(outDir, atlasName);
   const sidecarPath = join(outDir, `${base}.meta.json`);
-  const malformedCause = malformedAtlasTextureCause(atlas) ?? malformedGlyphCause(atlas);
-  if (malformedCause !== undefined) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: 'a valid MSDF atlas texture and glyph metrics',
-      hint: 'repair the MSDF generator atlas and glyph output, then retry the bake',
-      detail: { cause: malformedCause },
-    });
-  }
   const png = encodePng(atlas.texture.width, atlas.texture.height, atlas.texture.data);
-  try {
-    await writeFile(atlasPath, png);
-  } catch (e) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: 'a writable atlas output path',
-      hint: 'repair the atlas output path or filesystem access, then retry the bake',
-      detail: { path: atlasPath, cause: e instanceof Error ? e.message : String(e) },
-    });
-  }
+  await writeFile(atlasPath, png);
   const sidecar = atlasToSidecar(atlas, atlasName);
-  try {
-    await writeFile(sidecarPath, `${JSON.stringify(sidecar, null, 2)}\n`);
-  } catch (e) {
-    throw new FontError({
-      code: 'bake-failed',
-      expected: 'a writable sidecar output path',
-      hint: 'repair the sidecar output path or filesystem access, then retry the bake',
-      detail: { path: sidecarPath, cause: e instanceof Error ? e.message : String(e) },
-    });
-  }
+  await writeFile(sidecarPath, `${JSON.stringify(sidecar, null, 2)}\n`);
   return { atlasPath, sidecarPath };
 }
 

package/src/font-importer.ts

@@ -31,17 +31,15 @@
 // instead of the real wasm generator; production import calls fall through to
 // the real @zappar factory.
 
-import {
-  type FontAsset,
-  type GlyphMetric,
-  IMPORT_ERROR_HINTS,
-  type ImportContext,
-  ImportError,
-  type ImportedAsset,
-  type Importer,
-  type ImportResult,
-  type SamplerAsset,
-  type TextureAsset,
+import type {
+  FontAsset,
+  GlyphMetric,
+  ImportContext,
+  ImportedAsset,
+  Importer,
+  ImportResult,
+  SamplerAsset,
+  TextureAsset,
 } from '@forgeax/engine-types';
 import type { BakeAtlas, MsdfGenerator } from './cli-font.js';
 import { realGeneratorFactory } from './cli-font.js';
@@ -56,41 +54,6 @@ export function fontOutputSourceKeys(): readonly string[] {
   return ['texture', 'sampler', 'font'].map((kind) => sourceKeyForFontOutput(kind) as string);
 }
 
-const FONT_REQUIRED_KINDS = ['texture', 'sampler', 'font'] as const;
-const FONT_REQUIRED_TOPOLOGY = 'exactly one texture, one sampler, and one font subAsset';
-
-function validateRequiredFontSubAssets(ctx: ImportContext): ImportError | undefined {
-  const requiredKinds = new Set<string>(FONT_REQUIRED_KINDS);
-  const counts = new Map<string, number>();
-  for (const subAsset of ctx.subAssets) {
-    if (!requiredKinds.has(subAsset.kind)) continue;
-    counts.set(subAsset.kind, (counts.get(subAsset.kind) ?? 0) + 1);
-  }
-
-  const actual = FONT_REQUIRED_KINDS.map((kind) => `${kind}=${counts.get(kind) ?? 0}`).join(', ');
-  if (FONT_REQUIRED_KINDS.every((kind) => counts.get(kind) === 1)) return undefined;
-
-  return new ImportError({
-    code: 'source-validation-failed',
-    expected: FONT_REQUIRED_TOPOLOGY,
-    hint: IMPORT_ERROR_HINTS['source-validation-failed'],
-    detail: {
-      diagnostics: [
-        {
-          code: 'font-required-subasset-topology',
-          severity: 'error',
-          sourcePath: `${ctx.source}#subAssets`,
-          sourceRange: { start: 0, end: 0, line: 1, column: 1 },
-          rule: 'font-required-subasset-topology',
-          expected: FONT_REQUIRED_TOPOLOGY,
-          actual,
-          hint: 'Declare exactly one texture, one sampler, and one font subAsset before importing.',
-        },
-      ],
-    },
-  });
-}
-
 /** Map the @zappar atlas glyphs into the FontAsset glyph-metrics record. */
 function atlasGlyphsToMetrics(atlas: BakeAtlas): Record<number, GlyphMetric> {
   const glyphs: Record<number, GlyphMetric> = {};
@@ -148,23 +111,11 @@ function makeAtlasSampler(): SamplerAsset {
 }
 
 async function importFont(ctx: ImportContext): Promise<ImportResult> {
-  const topologyError = validateRequiredFontSubAssets(ctx);
-  if (topologyError !== undefined) return { ok: false, error: topologyError };
-
   const read = await ctx.readSource();
   if (!read.ok) {
-    return {
-      ok: false,
-      error: new ImportError({
-        code: 'source-read-failed',
-        expected: `readable source file at meta.source "${ctx.source}"`,
-        hint: IMPORT_ERROR_HINTS['source-read-failed'],
-        detail: {
-          source: ctx.source,
-          reason: read.error instanceof Error ? read.error.message : String(read.error),
-        },
-      }),
-    };
+    throw new Error(
+      `fontImporter: readSource failed: ${read.error instanceof Error ? read.error.message : String(read.error)}`,
+    );
   }
 
   const factory =