@forgeax/engine-font 0.1.2

package/dist/font-importer.d.ts

@@ -0,0 +1,18 @@
+import { type Importer } from '@forgeax/engine-types';
+/** Stable semantic identities for the three writable font outputs. */
+export declare function sourceKeyForFontOutput(kind: string): string | undefined;
+export declare function fontOutputSourceKeys(): readonly string[];
+/**
+ * The font {@link Importer}. Register it into an `ImporterRegistry` so the
+ * import runner dispatches `meta.importer === 'font'` sidecars here.
+ *
+ * @example
+ * ```ts
+ * import { ImporterRegistry } from '@forgeax/engine-import';
+ * import { fontImporter } from '@forgeax/engine-font/font-importer';
+ * const importers = new ImporterRegistry();
+ * importers.register(fontImporter);
+ * ```
+ */
+export declare const fontImporter: Importer;
+//# sourceMappingURL=font-importer.d.ts.map

package/dist/font-importer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-importer.d.ts","sourceRoot":"","sources":["../src/font-importer.ts"],"names":[],"mappings":"AAiCA,OAAO,EAOL,KAAK,QAAQ,EAId,MAAM,uBAAuB,CAAC;AAI/B,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGvE;AAED,wBAAgB,oBAAoB,IAAI,SAAS,MAAM,EAAE,CAExD;AAsLD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,EAAE,QAG1B,CAAC"}

package/dist/font-importer.mjs

@@ -0,0 +1,637 @@
+import { FontError, ImportError, IMPORT_ERROR_HINTS } from '@forgeax/engine-types';
+import { Buffer } from 'buffer';
+import { realpath, readFile, mkdir, writeFile } from 'fs/promises';
+import { basename, extname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { parseArgs } from 'util';
+import { deflateSync } from 'zlib';
+import { Worker } from 'worker_threads';
+
+// src/font-importer.ts
+var NodeWorkerAdapter = class {
+  worker;
+  listeners = /* @__PURE__ */ new Map();
+  constructor(url) {
+    this.worker = new Worker(url);
+  }
+  postMessage(message, transferList = []) {
+    this.worker.postMessage(message, [...transferList]);
+  }
+  addEventListener(type, listener) {
+    if (type !== "message") return;
+    const handler = (data) => listener({ data, origin: "*" });
+    this.listeners.set(listener, handler);
+    this.worker.on("message", handler);
+  }
+  removeEventListener(type, listener) {
+    if (type !== "message") return;
+    const handler = this.listeners.get(listener);
+    if (handler === void 0) return;
+    this.listeners.delete(listener);
+    this.worker.off("message", handler);
+  }
+  terminate() {
+    return this.worker.terminate();
+  }
+};
+
+// src/cli-font.ts
+var DEFAULT_CHARSET = (() => {
+  let s = "";
+  for (let c = 32; c <= 126; c++) s += String.fromCharCode(c);
+  return s;
+})();
+var DEFAULT_TEXTURE_SIZE = 1024;
+var DEFAULT_FIELD_RANGE = 4;
+var DEFAULT_FONT_SIZE = 48;
+function isSupportedFontMagic(bytes) {
+  if (bytes.length < 4) return false;
+  const b0 = bytes[0] ?? 0;
+  const b1 = bytes[1] ?? 0;
+  const b2 = bytes[2] ?? 0;
+  const b3 = bytes[3] ?? 0;
+  const isTrueType = b0 === 0 && b1 === 1 && b2 === 0 && b3 === 0;
+  const isTrue = b0 === 116 && b1 === 114 && b2 === 117 && b3 === 101;
+  const isOtto = b0 === 79 && b1 === 84 && b2 === 84 && b3 === 79;
+  return isTrueType || isTrue || isOtto;
+}
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc ^= bytes[i] ?? 0;
+    for (let k = 0; k < 8; k++) {
+      crc = crc & 1 ? crc >>> 1 ^ 3988292384 : crc >>> 1;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data) {
+  const typeBytes = new Uint8Array([
+    type.charCodeAt(0),
+    type.charCodeAt(1),
+    type.charCodeAt(2),
+    type.charCodeAt(3)
+  ]);
+  const body = new Uint8Array(typeBytes.length + data.length);
+  body.set(typeBytes, 0);
+  body.set(data, typeBytes.length);
+  const out = new Uint8Array(4 + body.length + 4);
+  const dv = new DataView(out.buffer);
+  dv.setUint32(0, data.length);
+  out.set(body, 4);
+  dv.setUint32(4 + body.length, crc32(body));
+  return out;
+}
+function encodePng(width, height, rgba) {
+  const stride = width * 4;
+  const raw = new Uint8Array((stride + 1) * height);
+  for (let y = 0; y < height; y++) {
+    raw[y * (stride + 1)] = 0;
+    raw.set(rgba.subarray(y * stride, y * stride + stride), y * (stride + 1) + 1);
+  }
+  const idat = deflateSync(raw);
+  const ihdr = new Uint8Array(13);
+  const dv = new DataView(ihdr.buffer);
+  dv.setUint32(0, width);
+  dv.setUint32(4, height);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+  const chunks = [
+    signature,
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", new Uint8Array(idat)),
+    pngChunk("IEND", new Uint8Array(0))
+  ];
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+function atlasToSidecar(atlas, sourcePng) {
+  const glyphs = {};
+  for (const g of atlas.glyphs) {
+    glyphs[g.unicode] = {
+      advance: g.advance,
+      bearingX: g.xoffset,
+      bearingY: g.yoffset,
+      size: { w: g.atlasSize[0], h: g.atlasSize[1] },
+      region: {
+        x: g.atlasPosition[0],
+        y: g.atlasPosition[1],
+        w: g.atlasSize[0],
+        h: g.atlasSize[1]
+      }
+    };
+  }
+  return {
+    schemaVersion: "1.0.0",
+    kind: "external-asset-package",
+    importer: "font",
+    source: sourcePng,
+    importSettings: { colorSpace: "linear", mipmap: "none" },
+    common: {
+      lineHeight: atlas.metrics.lineHeight,
+      base: atlas.metrics.ascender,
+      distanceRange: atlas.fieldRange,
+      pxRange: atlas.fieldRange,
+      atlasWidth: atlas.textureSize[0],
+      atlasHeight: atlas.textureSize[1]
+    },
+    glyphs
+  };
+}
+function malformedAtlasTextureCause(atlas) {
+  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 void 0;
+}
+function malformedGlyphCause(atlas) {
+  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 = /* @__PURE__ */ new Set();
+  for (let index = 0; index < atlas.glyphs.length; index += 1) {
+    const glyph = atlas.glyphs[index];
+    if (glyph === void 0) {
+      return `malformed-glyph: missing glyph record at index ${index}`;
+    }
+    if (!Number.isSafeInteger(glyph.unicode) || glyph.unicode < 0 || glyph.unicode > 1114111) {
+      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 void 0;
+}
+async function bakeFont(ttfPath, outDir, generatorFactory) {
+  let ttf;
+  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 ttfBytes = new Uint8Array(ttf.buffer, ttf.byteOffset, ttf.byteLength);
+  if (!isSupportedFontMagic(ttfBytes)) {
+    throw new FontError({
+      code: "unsupported-font-format",
+      expected: "ttf",
+      hint: 'bake accepts TrueType (.ttf / 0x00010000 / "true") or OpenType-TTF ("OTTO") sources; WOFF / WOFF2 / other formats are not supported -- convert to TTF first',
+      detail: { path: ttfPath }
+    });
+  }
+  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;
+  let generator;
+  let primaryFailure;
+  let primaryFailed = false;
+  let disposeFailure;
+  let disposeFailed = false;
+  try {
+    generator = await generatorFactory();
+    atlas = await generator.generateAtlas(ttfBytes);
+  } catch (e) {
+    primaryFailed = true;
+    primaryFailure = e;
+  } finally {
+    if (generator !== void 0) {
+      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 === void 0) {
+    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" }
+    });
+  }
+  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 !== void 0) {
+    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) }
+    });
+  }
+  const sidecar = atlasToSidecar(atlas, atlasName);
+  try {
+    await writeFile(sidecarPath, `${JSON.stringify(sidecar, null, 2)}
+`);
+  } 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) }
+    });
+  }
+  return { atlasPath, sidecarPath };
+}
+async function realGeneratorFactory() {
+  const mod = await import('@zappar/msdf-generator');
+  const wasmModuleUrl = import.meta.resolve("@zappar/msdf-generator/msdfgen_wasm.wasm");
+  const wasmBytes = await readFile(new URL(wasmModuleUrl));
+  const wasmUrl = `data:application/octet-stream;base64,${Buffer.from(wasmBytes).toString("base64")}`;
+  const nodeGlobal = globalThis;
+  const previousWorker = nodeGlobal.Worker;
+  nodeGlobal.Worker = NodeWorkerAdapter;
+  let msdf;
+  try {
+    msdf = new mod.MSDF({
+      workerUrl: new URL("./node-msdf-worker.mjs", import.meta.url),
+      wasmUrl
+    });
+    await msdf.initialize();
+  } finally {
+    if (previousWorker === void 0) {
+      delete nodeGlobal.Worker;
+    } else {
+      nodeGlobal.Worker = previousWorker;
+    }
+  }
+  if (msdf === void 0) {
+    throw new Error("the MSDF generator did not initialize");
+  }
+  return {
+    async generateAtlas(ttf) {
+      const a = await msdf.generateAtlas({
+        font: ttf,
+        charset: DEFAULT_CHARSET,
+        textureSize: [DEFAULT_TEXTURE_SIZE, DEFAULT_TEXTURE_SIZE],
+        fieldRange: DEFAULT_FIELD_RANGE,
+        fontSize: DEFAULT_FONT_SIZE
+      });
+      return {
+        texture: {
+          width: a.texture.width,
+          height: a.texture.height,
+          data: new Uint8Array(a.texture.data)
+        },
+        glyphs: a.glyphs.map((g) => ({
+          unicode: g.unicode,
+          advance: g.advance,
+          xoffset: g.xoffset,
+          yoffset: g.yoffset,
+          atlasPosition: [g.atlasPosition[0], g.atlasPosition[1]],
+          atlasSize: [g.atlasSize[0], g.atlasSize[1]]
+        })),
+        metrics: { lineHeight: a.metrics.lineHeight, ascender: a.metrics.ascender },
+        textureSize: [a.textureSize[0], a.textureSize[1]],
+        fieldRange: a.fieldRange
+      };
+    },
+    async dispose() {
+      await msdf.dispose();
+    }
+  };
+}
+function bakeHelpBody() {
+  return [
+    "forgeax-engine-remote-font bake \u2014 bake MSDF font atlas from TTF",
+    "",
+    "Usage:",
+    "  forgeax-engine-remote-font bake <ttf> <out>",
+    "",
+    "Reads a TrueType font file and produces:",
+    `  <out>/<basename>.atlas.png   \u2014 ${DEFAULT_TEXTURE_SIZE}x${DEFAULT_TEXTURE_SIZE} MSDF atlas`,
+    "  <out>/<basename>.meta.json   \u2014 glyph metrics sidecar (importer: font)",
+    ""
+  ].join("\n");
+}
+function helpBody() {
+  return [
+    "forgeax-engine-remote-font \u2014 MSDF font atlas baking",
+    "",
+    "Usage:",
+    "  forgeax-engine-remote-font bake <ttf> <out>",
+    ""
+  ].join("\n");
+}
+async function runCliFont(argv) {
+  const [sub, ...rest] = argv;
+  if (sub === void 0 || sub === "--help" || sub === "-h") {
+    process.stdout.write(`${helpBody()}
+`);
+    return 0;
+  }
+  if (sub !== "bake") {
+    process.stderr.write(`unknown subcommand: ${sub}
+`);
+    return 1;
+  }
+  return runBake(rest);
+}
+async function runBake(rest) {
+  if (rest[0] === "--help" || rest[0] === "-h") {
+    process.stdout.write(`${bakeHelpBody()}
+`);
+    return 0;
+  }
+  let positionals;
+  try {
+    const parsed = parseArgs({ args: rest, allowPositionals: true, strict: true });
+    positionals = [...parsed.positionals];
+  } catch {
+    process.stderr.write("error parsing CLI args\n");
+    return 1;
+  }
+  const ttfPath = positionals[0];
+  const outDir = positionals[1];
+  if (ttfPath === void 0 || outDir === void 0) {
+    process.stderr.write("usage: forgeax-engine-remote-font bake <ttf> <out>\n");
+    return 1;
+  }
+  try {
+    const result = await bakeFont(ttfPath, outDir, realGeneratorFactory);
+    process.stdout.write(`baked ${result.atlasPath} + ${result.sidecarPath}
+`);
+    return 0;
+  } catch (e) {
+    if (e instanceof FontError) {
+      process.stderr.write(
+        `${JSON.stringify({ code: e.code, expected: e.expected, hint: e.hint, detail: e.detail })}
+`
+      );
+      return 1;
+    }
+    process.stderr.write(`bake failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+}
+var isBinEntry = await (async () => {
+  const argv1 = process.argv[1];
+  if (typeof argv1 !== "string") return false;
+  const argv1Real = await realpath(argv1).catch(() => argv1);
+  const selfReal = await realpath(fileURLToPath(import.meta.url)).catch(
+    () => fileURLToPath(import.meta.url)
+  );
+  return argv1Real === selfReal;
+})();
+if (isBinEntry) {
+  const exitCode = await runCliFont(process.argv.slice(2));
+  process.exit(exitCode);
+}
+
+// src/font-importer.ts
+function sourceKeyForFontOutput(kind) {
+  const normalizedKind = kind.trim();
+  return normalizedKind.length === 0 ? void 0 : `font:${normalizedKind}`;
+}
+function fontOutputSourceKeys() {
+  return ["texture", "sampler", "font"].map((kind) => sourceKeyForFontOutput(kind));
+}
+var FONT_REQUIRED_KINDS = ["texture", "sampler", "font"];
+var FONT_REQUIRED_TOPOLOGY = "exactly one texture, one sampler, and one font subAsset";
+function validateRequiredFontSubAssets(ctx) {
+  const requiredKinds = new Set(FONT_REQUIRED_KINDS);
+  const counts = /* @__PURE__ */ new Map();
+  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 void 0;
+  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."
+        }
+      ]
+    }
+  });
+}
+function atlasGlyphsToMetrics(atlas) {
+  const glyphs = {};
+  for (const g of atlas.glyphs) {
+    glyphs[g.unicode] = {
+      advance: g.advance,
+      bearingX: g.xoffset,
+      bearingY: g.yoffset,
+      size: { w: g.atlasSize[0], h: g.atlasSize[1] },
+      region: {
+        x: g.atlasPosition[0],
+        y: g.atlasPosition[1],
+        w: g.atlasSize[0],
+        h: g.atlasSize[1]
+      }
+    };
+  }
+  return glyphs;
+}
+function makeAtlasTexture(atlas) {
+  return {
+    kind: "texture",
+    width: atlas.texture.width,
+    height: atlas.texture.height,
+    // MSDF atlas is linear-space RGBA8 (signed-distance channels, never gamma).
+    format: "rgba8unorm",
+    data: atlas.texture.data,
+    colorSpace: "linear",
+    mipmap: false
+  };
+}
+function makeFontCommon(atlas) {
+  return {
+    lineHeight: atlas.metrics.lineHeight,
+    base: atlas.metrics.ascender,
+    distanceRange: atlas.fieldRange,
+    pxRange: atlas.fieldRange,
+    atlasWidth: atlas.textureSize[0],
+    atlasHeight: atlas.textureSize[1]
+  };
+}
+function makeAtlasSampler() {
+  return {
+    kind: "sampler",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "nearest"
+  };
+}
+async function importFont(ctx) {
+  const topologyError = validateRequiredFontSubAssets(ctx);
+  if (topologyError !== void 0) 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)
+        }
+      })
+    };
+  }
+  const factory = ctx.importSettings.generatorFactory ?? realGeneratorFactory;
+  const generator = await factory();
+  let atlas;
+  try {
+    atlas = await generator.generateAtlas(read.value);
+  } finally {
+    await generator.dispose().catch(() => void 0);
+  }
+  const atlasSub = ctx.subAssets.find((s) => s.kind === "texture");
+  const samplerSub = ctx.subAssets.find((s) => s.kind === "sampler");
+  const fontSub = ctx.subAssets.find((s) => s.kind === "font");
+  const out = [];
+  if (atlasSub !== void 0) {
+    out.push({
+      guid: atlasSub.guid,
+      kind: "texture",
+      payload: makeAtlasTexture(atlas),
+      refs: [],
+      artifacts: {
+        atlas: {
+          // Pack v2's runtime texture loader consumes non-Basis artifacts as
+          // raw pixels. Keep the baked RGBA8 MSDF atlas in that form here;
+          // the CLI still emits a PNG for standalone bake output.
+          mediaType: "application/octet-stream",
+          bytes: atlas.texture.data
+        }
+      }
+    });
+  }
+  if (samplerSub !== void 0) {
+    out.push({
+      guid: samplerSub.guid,
+      kind: "sampler",
+      payload: makeAtlasSampler(),
+      refs: [],
+      artifacts: {}
+    });
+  }
+  if (fontSub !== void 0) {
+    const fontPayload = {
+      kind: "font",
+      atlasGuid: atlasSub?.guid ?? "",
+      samplerGuid: samplerSub?.guid ?? "",
+      glyphs: atlasGlyphsToMetrics(atlas),
+      common: makeFontCommon(atlas)
+    };
+    out.push({
+      guid: fontSub.guid,
+      kind: "font",
+      payload: fontPayload,
+      refs: [
+        ...atlasSub !== void 0 ? [{ guid: atlasSub.guid }] : [],
+        ...samplerSub !== void 0 ? [{ guid: samplerSub.guid }] : []
+      ],
+      artifacts: {}
+    });
+  }
+  return { ok: true, value: { assets: out, sourceDependencies: [] } };
+}
+var fontImporter = {
+  key: "font",
+  import: importFont
+};
+
+export { fontImporter, fontOutputSourceKeys, sourceKeyForFontOutput };
+//# sourceMappingURL=font-importer.mjs.map
+//# sourceMappingURL=font-importer.mjs.map