@shipload/item-renderer 0.2.1 → 0.2.3

package/test/base64url.test.ts

@@ -1,33 +1,33 @@
-import { expect, test } from 'bun:test'
-import { bytesToBase64Url, base64UrlToBytes } from '../src/payload/base64url.ts'
-import { InvalidPayloadError } from '../src/errors.ts'
+import { expect, test } from "bun:test";
+import { bytesToBase64Url, base64UrlToBytes } from "../src/payload/base64url.ts";
+import { InvalidPayloadError } from "../src/errors.ts";
 
-test('round-trips arbitrary bytes', () => {
+test("round-trips arbitrary bytes", () => {
   const inputs = [
     new Uint8Array([0]),
     new Uint8Array([255]),
     new Uint8Array([0, 1, 2, 3, 4, 5]),
     new Uint8Array(Array.from({ length: 256 }, (_, i) => i)),
-  ]
+  ];
   for (const input of inputs) {
-    const encoded = bytesToBase64Url(input)
-    const decoded = base64UrlToBytes(encoded)
-    expect(decoded).toEqual(input)
+    const encoded = bytesToBase64Url(input);
+    const decoded = base64UrlToBytes(encoded);
+    expect(decoded).toEqual(input);
   }
-})
+});
 
-test('produces only URL-safe characters — no +, /, =', () => {
-  const bytes = new Uint8Array(Array.from({ length: 256 }, (_, i) => i))
-  const encoded = bytesToBase64Url(bytes)
-  expect(encoded).toMatch(/^[A-Za-z0-9_-]+$/)
-})
+test("produces only URL-safe characters — no +, /, =", () => {
+  const bytes = new Uint8Array(Array.from({ length: 256 }, (_, i) => i));
+  const encoded = bytesToBase64Url(bytes);
+  expect(encoded).toMatch(/^[A-Za-z0-9_-]+$/);
+});
 
-test('rejects malformed base64url with InvalidPayloadError', () => {
-  expect(() => base64UrlToBytes('!!!not-base64!!!')).toThrow(InvalidPayloadError)
-  expect(() => base64UrlToBytes('has spaces')).toThrow(InvalidPayloadError)
-  expect(() => base64UrlToBytes('with+plus/slash')).toThrow(InvalidPayloadError)
-})
+test("rejects malformed base64url with InvalidPayloadError", () => {
+  expect(() => base64UrlToBytes("!!!not-base64!!!")).toThrow(InvalidPayloadError);
+  expect(() => base64UrlToBytes("has spaces")).toThrow(InvalidPayloadError);
+  expect(() => base64UrlToBytes("with+plus/slash")).toThrow(InvalidPayloadError);
+});
 
-test('accepts known-good short string', () => {
-  expect(base64UrlToBytes('AAA')).toEqual(new Uint8Array([0, 0]))
-})
+test("accepts known-good short string", () => {
+  expect(base64UrlToBytes("AAA")).toEqual(new Uint8Array([0, 0]));
+});

package/test/codec.test.ts

@@ -1,43 +1,34 @@
-import { expect, test } from 'bun:test'
-import { encodePayload, decodePayload } from '../src/payload/codec.ts'
-import { InvalidPayloadError } from '../src/errors.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { expect, test } from "bun:test";
+import { encodePayload, decodePayload } from "../src/payload/codec.ts";
+import { InvalidPayloadError } from "../src/errors.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
-test('round-trips every fixture exactly', () => {
+test("round-trips every fixture exactly", () => {
   for (const [name, item] of Object.entries(FIXTURES)) {
-    const encoded = encodePayload(item)
-    const decoded = decodePayload(encoded)
-    expect(
-      decoded.item_id.equals(item.item_id),
-      `${name} item_id`,
-    ).toBe(true)
-    expect(
-      decoded.quantity.equals(item.quantity),
-      `${name} quantity`,
-    ).toBe(true)
-    expect(
-      decoded.stats.equals(item.stats),
-      `${name} stats`,
-    ).toBe(true)
-    expect(decoded.modules.length, `${name} modules length`).toBe(item.modules.length)
+    const encoded = encodePayload(item);
+    const decoded = decodePayload(encoded);
+    expect(decoded.item_id.equals(item.item_id), `${name} item_id`).toBe(true);
+    expect(decoded.quantity.equals(item.quantity), `${name} quantity`).toBe(true);
+    expect(decoded.stats.equals(item.stats), `${name} stats`).toBe(true);
+    expect(decoded.modules.length, `${name} modules length`).toBe(item.modules.length);
   }
-})
+});
 
-test('encoded payload is URL-safe', () => {
+test("encoded payload is URL-safe", () => {
   for (const item of Object.values(FIXTURES)) {
-    const encoded = encodePayload(item)
-    expect(encoded).toMatch(/^[A-Za-z0-9_-]+$/)
+    const encoded = encodePayload(item);
+    expect(encoded).toMatch(/^[A-Za-z0-9_-]+$/);
   }
-})
+});
 
-test('decodePayload throws InvalidPayloadError on malformed input', () => {
-  expect(() => decodePayload('!!!')).toThrow(InvalidPayloadError)
-  expect(() => decodePayload('AAA')).toThrow(InvalidPayloadError)
-  expect(() => decodePayload('')).toThrow(InvalidPayloadError)
-})
+test("decodePayload throws InvalidPayloadError on malformed input", () => {
+  expect(() => decodePayload("!!!")).toThrow(InvalidPayloadError);
+  expect(() => decodePayload("AAA")).toThrow(InvalidPayloadError);
+  expect(() => decodePayload("")).toThrow(InvalidPayloadError);
+});
 
-test('payload sizes are within expected ranges', () => {
-  expect(encodePayload(FIXTURES.oreT1).length).toBeLessThan(30)
-  expect(encodePayload(FIXTURES.shipT1NoModules).length).toBeLessThan(30)
-  expect(encodePayload(FIXTURES.shipT1TwoModules).length).toBeLessThan(110)
-})
+test("payload sizes are within expected ranges", () => {
+  expect(encodePayload(FIXTURES.oreT1).length).toBeLessThan(30);
+  expect(encodePayload(FIXTURES.shipT1NoModules).length).toBeLessThan(30);
+  expect(encodePayload(FIXTURES.shipT1TwoModules).length).toBeLessThan(110);
+});

package/test/errors.test.ts

@@ -1,24 +1,24 @@
-import { expect, test } from 'bun:test'
-import { InvalidPayloadError, UnknownItemError, RenderError } from '../src/errors.ts'
+import { expect, test } from "bun:test";
+import { InvalidPayloadError, UnknownItemError, RenderError } from "../src/errors.ts";
 
-test('InvalidPayloadError preserves the message and is an Error', () => {
-  const e = new InvalidPayloadError('bad base64')
-  expect(e).toBeInstanceOf(Error)
-  expect(e).toBeInstanceOf(InvalidPayloadError)
-  expect(e.message).toBe('bad base64')
-  expect(e.name).toBe('InvalidPayloadError')
-})
+test("InvalidPayloadError preserves the message and is an Error", () => {
+  const e = new InvalidPayloadError("bad base64");
+  expect(e).toBeInstanceOf(Error);
+  expect(e).toBeInstanceOf(InvalidPayloadError);
+  expect(e.message).toBe("bad base64");
+  expect(e.name).toBe("InvalidPayloadError");
+});
 
-test('UnknownItemError carries the item id', () => {
-  const e = new UnknownItemError(9999)
-  expect(e).toBeInstanceOf(UnknownItemError)
-  expect(e.itemId).toBe(9999)
-  expect(e.message).toContain('9999')
-})
+test("UnknownItemError carries the item id", () => {
+  const e = new UnknownItemError(9999);
+  expect(e).toBeInstanceOf(UnknownItemError);
+  expect(e.itemId).toBe(9999);
+  expect(e.message).toContain("9999");
+});
 
-test('RenderError wraps a cause', () => {
-  const cause = new Error('inner')
-  const e = new RenderError('render failed', { cause })
-  expect(e).toBeInstanceOf(RenderError)
-  expect(e.cause).toBe(cause)
-})
+test("RenderError wraps a cause", () => {
+  const cause = new Error("inner");
+  const e = new RenderError("render failed", { cause });
+  expect(e).toBeInstanceOf(RenderError);
+  expect(e.cause).toBe(cause);
+});

package/test/fixtures/cargo-items.ts

@@ -1,122 +1,122 @@
-import { ServerContract } from '@shipload/sdk'
+import { ServerContract } from "@shipload/sdk";
 
-export const ITEM_ORE_T1 = 101
-export const ITEM_GAS_T2 = 302
-export const ITEM_ENGINE_T1 = 10100
-export const ITEM_GENERATOR_T1 = 10101
-export const ITEM_GATHERER_T1 = 10102
-export const ITEM_LOADER_T1 = 10103
-export const ITEM_MANUFACTURING_T1 = 10104
-export const ITEM_STORAGE_T1 = 10105
-export const ITEM_HAULER_T1 = 10106
-export const ITEM_SHIP_T1_PACKED = 10201
+export const ITEM_ORE_T1 = 101;
+export const ITEM_GAS_T2 = 302;
+export const ITEM_ENGINE_T1 = 10100;
+export const ITEM_GENERATOR_T1 = 10101;
+export const ITEM_GATHERER_T1 = 10102;
+export const ITEM_LOADER_T1 = 10103;
+export const ITEM_MANUFACTURING_T1 = 10104;
+export const ITEM_STORAGE_T1 = 10105;
+export const ITEM_HAULER_T1 = 10106;
+export const ITEM_SHIP_T1_PACKED = 10201;
 
-export const MODULE_ENGINE = 1
-export const MODULE_GENERATOR = 2
+export const MODULE_ENGINE = 1;
+export const MODULE_GENERATOR = 2;
 
-export function cargoOreT1(stats = '0x123456789ABCDEF', quantity = 1) {
+export function cargoOreT1(stats = "0x123456789ABCDEF", quantity = 1) {
   return ServerContract.Types.cargo_item.from({
     item_id: ITEM_ORE_T1,
     quantity,
     stats,
     modules: [],
-  })
+  });
 }
 
 export function cargoShipT1Packed(opts?: {
-  stats?: string
-  engineStats?: string
-  generatorStats?: string
-  onlyEngine?: boolean
+  stats?: string;
+  engineStats?: string;
+  generatorStats?: string;
+  onlyEngine?: boolean;
 }) {
-  const o = opts ?? {}
-  const modules: unknown[] = []
+  const o = opts ?? {};
+  const modules: unknown[] = [];
   modules.push({
     type: MODULE_ENGINE,
-    installed: { item_id: ITEM_ENGINE_T1, stats: o.engineStats ?? '0x2A4F6B8C' },
-  })
+    installed: { item_id: ITEM_ENGINE_T1, stats: o.engineStats ?? "0x2A4F6B8C" },
+  });
   if (!o.onlyEngine) {
     modules.push({
       type: MODULE_GENERATOR,
-      installed: { item_id: ITEM_GENERATOR_T1, stats: o.generatorStats ?? '0x1B2D4F' },
-    })
+      installed: { item_id: ITEM_GENERATOR_T1, stats: o.generatorStats ?? "0x1B2D4F" },
+    });
   }
   return ServerContract.Types.cargo_item.from({
     item_id: ITEM_SHIP_T1_PACKED,
     quantity: 1,
-    stats: o.stats ?? '0',
+    stats: o.stats ?? "0",
     modules,
-  })
+  });
 }
 
-export const ITEM_HULL_PLATES = 10001
+export const ITEM_HULL_PLATES = 10001;
 
 export const FIXTURES = {
-  oreT1: cargoOreT1('0x123456789ABCDEF'),
-  oreT1StackOf50: cargoOreT1('0x123456789ABCDEF', 50),
-  oreT1ZeroStats: cargoOreT1('0'),
+  oreT1: cargoOreT1("0x123456789ABCDEF"),
+  oreT1StackOf50: cargoOreT1("0x123456789ABCDEF", 50),
+  oreT1ZeroStats: cargoOreT1("0"),
   gasT2: ServerContract.Types.cargo_item.from({
     item_id: ITEM_GAS_T2,
     quantity: 1,
-    stats: '0xDEADBEEF1234',
+    stats: "0xDEADBEEF1234",
     modules: [],
   }),
   hullPlates: ServerContract.Types.cargo_item.from({
     item_id: ITEM_HULL_PLATES,
     quantity: 1,
-    stats: '0x7FFF',
+    stats: "0x7FFF",
     modules: [],
   }),
   engineT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_ENGINE_T1,
     quantity: 1,
-    stats: '358800',
+    stats: "358800",
     modules: [],
   }),
   generatorT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_GENERATOR_T1,
     quantity: 1,
-    stats: '683908',
+    stats: "683908",
     modules: [],
   }),
   gathererT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_GATHERER_T1,
     quantity: 1,
-    stats: '138255128433040',
+    stats: "138255128433040",
     modules: [],
   }),
   loaderT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_LOADER_T1,
     quantity: 1,
-    stats: '512750',
+    stats: "512750",
     modules: [],
   }),
   crafterT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_MANUFACTURING_T1,
     quantity: 1,
-    stats: '512600',
+    stats: "512600",
     modules: [],
   }),
   storageT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_STORAGE_T1,
     quantity: 1,
-    stats: '537605632700',
+    stats: "537605632700",
     modules: [],
   }),
   haulerT1: ServerContract.Types.cargo_item.from({
     item_id: ITEM_HAULER_T1,
     quantity: 1,
-    stats: '0x3E8',
+    stats: "0x3E8",
     modules: [],
   }),
   shipT1NoModules: ServerContract.Types.cargo_item.from({
     item_id: ITEM_SHIP_T1_PACKED,
     quantity: 1,
-    stats: '0',
+    stats: "0",
     modules: [],
   }),
   shipT1TwoModules: cargoShipT1Packed(),
   shipT1OnlyEngine: cargoShipT1Packed({ onlyEngine: true }),
-} as const
+} as const;
 
-export type FixtureName = keyof typeof FIXTURES
+export type FixtureName = keyof typeof FIXTURES;

package/test/fonts.test.ts

@@ -1,28 +1,28 @@
-import { expect, test } from 'bun:test'
-import { embedFontsInSvg } from '../src/fonts/index.ts'
-import { loadFontData } from '../src/fonts/load-bun.ts'
+import { expect, test } from "bun:test";
+import { embedFontsInSvg } from "../src/fonts/index.ts";
+import { loadFontData } from "../src/fonts/load-bun.ts";
 
-test('loadFontData returns all four faces with non-zero bytes', async () => {
-  const data = await loadFontData()
+test("loadFontData returns all four faces with non-zero bytes", async () => {
+  const data = await loadFontData();
   expect(Object.keys(data).sort()).toEqual([
-    'inter-400',
-    'inter-600',
-    'jetbrains-500',
-    'orbitron-700',
-  ])
+    "inter-400",
+    "inter-600",
+    "jetbrains-500",
+    "orbitron-700",
+  ]);
   for (const [key, bytes] of Object.entries(data)) {
-    expect(bytes.byteLength, `${key} bytes`).toBeGreaterThan(2000)
-    expect(bytes.byteLength, `${key} bytes`).toBeLessThan(120_000)
+    expect(bytes.byteLength, `${key} bytes`).toBeGreaterThan(2000);
+    expect(bytes.byteLength, `${key} bytes`).toBeLessThan(120_000);
   }
-})
+});
 
-test('embedFontsInSvg inlines @font-face blocks', async () => {
-  const data = await loadFontData()
-  const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"></svg>'
-  const out = embedFontsInSvg(svg, data)
-  expect(out).toContain('@font-face')
-  expect(out).toContain('font-family: "Orbitron"')
-  expect(out).toContain('font-family: "Inter"')
-  expect(out).toContain('font-family: "JetBrains Mono"')
-  expect(out).toContain('data:font/woff2;base64,')
-})
+test("embedFontsInSvg inlines @font-face blocks", async () => {
+  const data = await loadFontData();
+  const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"></svg>';
+  const out = embedFontsInSvg(svg, data);
+  expect(out).toContain("@font-face");
+  expect(out).toContain('font-family: "Orbitron"');
+  expect(out).toContain('font-family: "Inter"');
+  expect(out).toContain('font-family: "JetBrains Mono"');
+  expect(out).toContain("data:font/woff2;base64,");
+});

package/test/links-meta.test.ts

@@ -1,43 +1,43 @@
-import { expect, test } from 'bun:test'
-import { resolveItem } from '@shipload/sdk'
-import { linkToItemImage, linkToItemPage, linkToItemSocial } from '../src/links.ts'
-import { itemPageMeta } from '../src/meta.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { expect, test } from "bun:test";
+import { resolveItem } from "@shipload/sdk";
+import { linkToItemImage, linkToItemPage, linkToItemSocial } from "../src/links.ts";
+import { itemPageMeta } from "../src/meta.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
-test('linkToItemPage defaults to shiploadgame.com', () => {
-  const url = linkToItemPage(FIXTURES.oreT1)
-  expect(url).toMatch(/^https:\/\/shiploadgame\.com\/guide\/item\/[A-Za-z0-9_-]+$/)
-})
+test("linkToItemPage defaults to shiploadgame.com", () => {
+  const url = linkToItemPage(FIXTURES.oreT1);
+  expect(url).toMatch(/^https:\/\/shiploadgame\.com\/guide\/item\/[A-Za-z0-9_-]+$/);
+});
 
-test('linkToItemPage accepts a custom base URL', () => {
-  const url = linkToItemPage(FIXTURES.oreT1, 'http://localhost:5173')
-  expect(url.startsWith('http://localhost:5173/guide/item/')).toBe(true)
-})
+test("linkToItemPage accepts a custom base URL", () => {
+  const url = linkToItemPage(FIXTURES.oreT1, "http://localhost:5173");
+  expect(url.startsWith("http://localhost:5173/guide/item/")).toBe(true);
+});
 
-test('linkToItemImage builds a PNG URL', () => {
-  const url = linkToItemImage(FIXTURES.oreT1, 'png')
-  expect(url).toMatch(/^https:\/\/item\.shiploadgame\.com\/item\/[A-Za-z0-9_-]+\.png$/)
-})
+test("linkToItemImage builds a PNG URL", () => {
+  const url = linkToItemImage(FIXTURES.oreT1, "png");
+  expect(url).toMatch(/^https:\/\/item\.shiploadgame\.com\/item\/[A-Za-z0-9_-]+\.png$/);
+});
 
-test('linkToItemImage builds an SVG URL', () => {
-  const url = linkToItemImage(FIXTURES.oreT1, 'svg')
-  expect(url).toMatch(/\.svg$/)
-})
+test("linkToItemImage builds an SVG URL", () => {
+  const url = linkToItemImage(FIXTURES.oreT1, "svg");
+  expect(url).toMatch(/\.svg$/);
+});
 
-test('linkToItemSocial builds a social card URL', () => {
-  const url = linkToItemSocial(FIXTURES.oreT1)
-  expect(url).toMatch(/^https:\/\/item\.shiploadgame\.com\/social\/[A-Za-z0-9_-]+\.png$/)
-})
+test("linkToItemSocial builds a social card URL", () => {
+  const url = linkToItemSocial(FIXTURES.oreT1);
+  expect(url).toMatch(/^https:\/\/item\.shiploadgame\.com\/social\/[A-Za-z0-9_-]+\.png$/);
+});
 
-test('itemPageMeta produces title, description, and ogImage (social card)', () => {
-  const item = FIXTURES.oreT1
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const meta = itemPageMeta(item, resolved)
-  expect(meta.title).toContain('Crude Ore')
-  expect(meta.description).toContain('T1 Ore')
-  expect(meta.description).toMatch(/Strength \d+/)
-  expect(meta.description).toMatch(/\d+(\.\d+)? t$/)
-  expect(meta.ogImage).toMatch(/^https:\/\/item\.shiploadgame\.com\/social\/[A-Za-z0-9_-]+\.png$/)
-  expect(meta.ogImageWidth).toBe(1200)
-  expect(meta.ogImageHeight).toBe(630)
-})
+test("itemPageMeta produces title, description, and ogImage (social card)", () => {
+  const item = FIXTURES.oreT1;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const meta = itemPageMeta(item, resolved);
+  expect(meta.title).toContain("Crude Ore");
+  expect(meta.description).toContain("T1 Ore");
+  expect(meta.description).toMatch(/Strength \d+/);
+  expect(meta.description).toMatch(/\d+(\.\d+)? t$/);
+  expect(meta.ogImage).toMatch(/^https:\/\/item\.shiploadgame\.com\/social\/[A-Za-z0-9_-]+\.png$/);
+  expect(meta.ogImageWidth).toBe(1200);
+  expect(meta.ogImageHeight).toBe(630);
+});

package/test/pixel.test.ts

@@ -1,55 +1,58 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { expect, test } from 'bun:test'
-import { Resvg } from '@resvg/resvg-js'
-import pixelmatch from 'pixelmatch'
-import { PNG } from 'pngjs'
-import { resolveItem } from '@shipload/sdk'
-import { renderItem } from '../src/render.ts'
-import { embedFontsInSvg } from '../src/fonts/index.ts'
-import { loadFontData } from '../src/fonts/load-bun.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { expect, test } from "bun:test";
+import { Resvg } from "@resvg/resvg-js";
+import pixelmatch from "pixelmatch";
+import { PNG } from "pngjs";
+import { resolveItem } from "@shipload/sdk";
+import { renderItem } from "../src/render.ts";
+import { embedFontsInSvg } from "../src/fonts/index.ts";
+import { loadFontData } from "../src/fonts/load-bun.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
-const SNAP_DIR = resolve(import.meta.dir, '__image_snapshots__')
-const UPDATE = process.env.UPDATE_IMAGE_SNAPSHOTS === '1'
+const SNAP_DIR = resolve(import.meta.dir, "__image_snapshots__");
+const UPDATE = process.env.UPDATE_IMAGE_SNAPSHOTS === "1";
 
-await mkdir(SNAP_DIR, { recursive: true })
-const fontData = await loadFontData()
+await mkdir(SNAP_DIR, { recursive: true });
+const fontData = await loadFontData();
 
 async function renderPng(svg: string): Promise<Buffer> {
   const resvg = new Resvg(svg, {
-    font: { loadSystemFonts: false, fontBuffers: Object.values(fontData).map((b) => Buffer.from(b)) },
-  })
-  return resvg.render().asPng()
+    font: {
+      loadSystemFonts: false,
+      fontBuffers: Object.values(fontData).map((b) => Buffer.from(b)),
+    },
+  });
+  return resvg.render().asPng();
 }
 
 const CASES = [
-  { name: 'resource-ore-t1', fixture: FIXTURES.oreT1 },
-  { name: 'packed-entity-ship-t1-two-modules', fixture: FIXTURES.shipT1TwoModules },
-  { name: 'packed-entity-ship-t1-only-engine', fixture: FIXTURES.shipT1OnlyEngine },
-  { name: 'component-hull-plates', fixture: FIXTURES.hullPlates },
-  { name: 'module-engine-t1', fixture: FIXTURES.engineT1 },
-  { name: 'module-storage-t1', fixture: FIXTURES.storageT1 },
-] as const
+  { name: "resource-ore-t1", fixture: FIXTURES.oreT1 },
+  { name: "packed-entity-ship-t1-two-modules", fixture: FIXTURES.shipT1TwoModules },
+  { name: "packed-entity-ship-t1-only-engine", fixture: FIXTURES.shipT1OnlyEngine },
+  { name: "component-hull-plates", fixture: FIXTURES.hullPlates },
+  { name: "module-engine-t1", fixture: FIXTURES.engineT1 },
+  { name: "module-storage-t1", fixture: FIXTURES.storageT1 },
+] as const;
 
 for (const c of CASES) {
   test(`pixel golden — ${c.name}`, async () => {
-    const resolved = resolveItem(c.fixture.item_id, c.fixture.stats, c.fixture.modules)
-    const svg = embedFontsInSvg(renderItem(c.fixture, resolved), fontData)
-    const png = await renderPng(svg)
-    const goldPath = resolve(SNAP_DIR, `${c.name}.png`)
+    const resolved = resolveItem(c.fixture.item_id, c.fixture.stats, c.fixture.modules);
+    const svg = embedFontsInSvg(renderItem(c.fixture, resolved), fontData);
+    const png = await renderPng(svg);
+    const goldPath = resolve(SNAP_DIR, `${c.name}.png`);
 
     if (UPDATE || !existsSync(goldPath)) {
-      await writeFile(goldPath, png)
-      return
+      await writeFile(goldPath, png);
+      return;
     }
 
-    const actual = PNG.sync.read(png)
-    const expected = PNG.sync.read(await readFile(goldPath))
-    expect(actual.width).toBe(expected.width)
-    expect(actual.height).toBe(expected.height)
-    const diff = new PNG({ width: actual.width, height: actual.height })
+    const actual = PNG.sync.read(png);
+    const expected = PNG.sync.read(await readFile(goldPath));
+    expect(actual.width).toBe(expected.width);
+    expect(actual.height).toBe(expected.height);
+    const diff = new PNG({ width: actual.width, height: actual.height });
     const diffCount = pixelmatch(
       actual.data,
       expected.data,
@@ -57,10 +60,10 @@ for (const c of CASES) {
       actual.width,
       actual.height,
       { threshold: 0.1 },
-    )
+    );
     if (diffCount > 10) {
-      await writeFile(resolve(SNAP_DIR, `${c.name}.diff.png`), PNG.sync.write(diff))
+      await writeFile(resolve(SNAP_DIR, `${c.name}.diff.png`), PNG.sync.write(diff));
     }
-    expect(diffCount).toBeLessThanOrEqual(10)
-  })
+    expect(diffCount).toBeLessThanOrEqual(10);
+  });
 }