fix(image-generator): make the package actually work standalone

Author: heyradcode

image-generator/package.json

@@ -2,6 +2,7 @@
     "name": "image-generator",
     "version": "0.0.1",
     "private": true,
+    "packageManager": "pnpm@9.15.9",
     "description": "Standalone microservice that renders deterministic pet NFT art (SVG) and ERC-721 metadata from a pet's on-chain DNA.",
     "license": "SEE LICENSE IN ../LICENSE",
     "type": "module",

image-generator/src/digitPair.test.ts

@@ -11,7 +11,11 @@
  * `contracts/test-vectors/battle.json`. Agreeing with it makes this port correct
  * transitively, without importing anything at build time.
  *
- * Skipped when the monorepo is absent, so the service still tests standalone.
+ * Skipped when the monorepo is absent, so the service still tests standalone. The
+ * specifier is assembled at runtime rather than written as a literal: tsc resolves
+ * a literal dynamic import, so a static path would make `pnpm typecheck` fail
+ * wherever the monorepo is not checked out, which is exactly the isolation this
+ * package is meant to keep.
  */
 
 import { existsSync } from 'node:fs';
@@ -21,13 +25,22 @@ import { digitPair } from './traits.js';
 
 const SHARED_DNA = join('..', 'shared', 'src', 'utils', 'combat', 'dna.ts');
 
+interface DnaPort {
+    digitPair: (dna: bigint, pairIdx: number) => bigint;
+}
+
+/** Resolved to an absolute file URL against this file, so the path is right at
+ *  runtime while staying a plain string to tsc; see the note above. */
+const loadSharedPort = async (): Promise<DnaPort> => {
+    const specifier = new URL('../../shared/src/utils/combat/dna.ts', import.meta.url).href;
+    return (await import(/* @vite-ignore */ specifier)) as DnaPort;
+};
+
 const describeIfPresent = existsSync(SHARED_DNA) ? describe : describe.skip;
 
 describeIfPresent('digitPair vs the golden-vector-checked port', () => {
     it('agrees across every pair index, for DNA of every shape', async () => {
-        const shared = (await import('../../shared/src/utils/combat/dna.js')) as {
-            digitPair: (dna: bigint, pairIdx: number) => bigint;
-        };
+        const shared = await loadSharedPort();
 
         const samples = [
             0n,
@@ -51,9 +64,7 @@ describeIfPresent('digitPair vs the golden-vector-checked port', () => {
     });
 
     it('agrees across a sweep, not just hand-picked values', async () => {
-        const shared = (await import('../../shared/src/utils/combat/dna.js')) as {
-            digitPair: (dna: bigint, pairIdx: number) => bigint;
-        };
+        const shared = await loadSharedPort();
 
         for (let i = 0n; i < 500n; i++) {
             const dna = (i * 7_919_000_000_037n) % 10_000_000_000_000_000n;

image-generator/src/solanaLayout.test.ts

@@ -51,61 +51,71 @@ const ourFields = FIELD_SIZES.slice(1).map(([name, bytes]) => [name, bytes] as [
 
 const describeIf = (path: string) => (existsSync(path) ? describe : describe.skip);
 
-describeIf(IDL_PATH)('PetAccount layout vs the Anchor IDL', () => {
+// Read inside the tests, never in a describe body: vitest evaluates the body of a
+// skipped describe, so a top-level readFileSync throws where the file is absent
+// and the skip never gets a chance to apply.
+const readIdl = () => {
     const idl = JSON.parse(readFileSync(IDL_PATH, 'utf8')) as {
         accounts?: { name: string; discriminator: number[] }[];
         types?: { name: string; type: { fields: { name: string; type: IdlType }[] } }[];
     };
     const fields = idl.types?.find((t) => t.name === 'PetAccount')?.type.fields ?? [];
-    const idlLayout = fields.map((f) => [f.name, widthOf(f.type)] as [string, number]);
+    return { idl, layout: fields.map((f) => [f.name, widthOf(f.type)] as [string, number]) };
+};
+
+describeIf(IDL_PATH)('PetAccount layout vs the Anchor IDL', () => {
 
     // Guards the guard: an empty layout would agree with anything.
     it('found the account in the IDL', () => {
-        expect(idlLayout.length).toBeGreaterThan(20);
+        expect(readIdl().layout.length).toBeGreaterThan(20);
     });
 
     it('has the same fields, in the same order, at the same widths', () => {
-        expect(ourFields).toEqual(idlLayout);
+        expect(ourFields).toEqual(readIdl().layout);
     });
 
     it('totals the same account size once the discriminator is added', () => {
-        const total = idlLayout.reduce((sum, [, bytes]) => sum + bytes, 0);
+        const total = readIdl().layout.reduce((sum, [, bytes]) => sum + bytes, 0);
         expect(PET_ACCOUNT_SPACE).toBe(total + 8);
     });
 
     // Computed as sha256("account:PetAccount")[0..8] rather than read from
     // anywhere. If that convention were wrong, every real account would fail the
     // discriminator check and Solana would never serve a single pet.
     it('computes the discriminator Anchor generated', () => {
-        const expected = idl.accounts?.find((a) => a.name === 'PetAccount')?.discriminator;
+        const expected = readIdl().idl.accounts?.find((a) => a.name === 'PetAccount')?.discriminator;
         expect(expected).toBeDefined();
         expect([...petAccountDiscriminator()]).toEqual(expected);
     });
 });
 
-describeIf(PET_RS)('PetAccount layout vs pet.rs', () => {
+/** Same reason as readIdl: never read at describe level. */
+const readRustLayout = (): [string, number][] => {
     const toCamel = (name: string): string =>
         name.replace(/^_+/, '').replace(/_([a-z])/g, (_full, c: string) => c.toUpperCase());
 
     const source = readFileSync(PET_RS, 'utf8');
     const body = source.slice(source.indexOf('pub struct PetAccount {'), source.indexOf('impl PetAccount'));
 
-    const rustLayout: [string, number][] = [];
+    const layout: [string, number][] = [];
     for (const line of body.split('\n')) {
         const match = /^\s*pub\s+(\w+):\s*([^,]+),/.exec(line);
         if (!match) continue;
         const type = match[2]!.trim().replace('PetAccount::MAX_NAME_LEN', '32');
         const array = /^\[u8;\s*(\d+)\]$/.exec(type);
-        rustLayout.push([toCamel(match[1]!), array ? Number(array[1]) : widthOf(type)]);
+        layout.push([toCamel(match[1]!), array ? Number(array[1]) : widthOf(type)]);
     }
+    return layout;
+};
 
+describeIf(PET_RS)('PetAccount layout vs pet.rs', () => {
     it('found the struct in the source', () => {
-        expect(rustLayout.length).toBeGreaterThan(20);
+        expect(readRustLayout().length).toBeGreaterThan(20);
     });
 
     // Disagreement here means the checked-in IDL no longer matches the program
     // source, so this service would decode for a program that is not deployed.
     it('matches the current Rust struct too, so the IDL is not stale', () => {
-        expect(ourFields).toEqual(rustLayout);
+        expect(ourFields).toEqual(readRustLayout());
     });
 });

image-generator/src/traitAlignment.test.ts

@@ -43,37 +43,39 @@ const BODY_FOR_SKILL: readonly [skill: string, body: string][] = [
     ['Bloodlust', 'Fanged'],
 ];
 
-describeIf(SKILLS)('body silhouettes vs the skill archetypes', () => {
-    const source = readFileSync(SKILLS, 'utf8');
-    const skills = [...source.matchAll(/name:\s*'([A-Za-z]+)'/g)].map((m) => m[1]!);
+// Read inside the tests, never in a describe body: vitest evaluates the body of a
+// skipped describe, so a top-level read throws where the monorepo is absent and
+// the skip never gets a chance to apply.
+const readSkills = (): string[] =>
+    [...readFileSync(SKILLS, 'utf8').matchAll(/name:\s*'([A-Za-z]+)'/g)].map((m) => m[1]!);
+
+const readElements = () => /const elements = \[([^\]]+)\]/.exec(readFileSync(PET_CARD, 'utf8'));
 
+describeIf(SKILLS)('body silhouettes vs the skill archetypes', () => {
     it('found the archetype list', () => {
-        expect(skills.length).toBeGreaterThan(4);
+        expect(readSkills().length).toBeGreaterThan(4);
     });
 
     it('has one silhouette per archetype', () => {
-        expect(BODY_NAMES).toHaveLength(skills.length);
+        expect(BODY_NAMES).toHaveLength(readSkills().length);
     });
 
     // Both are indexed by speciesId % 8, so position is the whole contract.
     it('pairs each silhouette with the archetype at the same index', () => {
-        expect(skills).toEqual(BODY_FOR_SKILL.map(([skill]) => skill));
+        expect(readSkills()).toEqual(BODY_FOR_SKILL.map(([skill]) => skill));
         expect([...BODY_NAMES]).toEqual(BODY_FOR_SKILL.map(([, body]) => body));
     });
 });
 
 describeIf(PET_CARD)('element names vs the game element wheel', () => {
-    const source = readFileSync(PET_CARD, 'utf8');
-    const match = /const elements = \[([^\]]+)\]/.exec(source);
-
     it('found the element list', () => {
-        expect(match).not.toBeNull();
+        expect(readElements()).not.toBeNull();
     });
 
     // Order is the palette: element 1 must mean the same thing in both places, or
     // a pet's metadata would name one element while the app names another.
     it('is the same list in the same order', () => {
-        const theirs = match![1]!.split(',').map((s) => s.trim().replace(/'/g, ''));
+        const theirs = readElements()![1]!.split(',').map((s) => s.trim().replace(/'/g, ''));
         const capitalised = theirs.map((name) => name[0]!.toUpperCase() + name.slice(1));
 
         expect([...ELEMENT_NAMES]).toEqual(capitalised);

image-generator/tsconfig.test.json

@@ -6,13 +6,7 @@
     "extends": "./tsconfig.json",
     "compilerOptions": {
         "noEmit": true,
-        "types": ["node"],
-        // Widened past ./src because digitPair.test.ts deliberately imports a
-        // sibling package's port to check this service's copy against it. Nothing
-        // is emitted from this config, so rootDir only has to be wide enough to
-        // contain the program. The build config keeps ./src, so production code
-        // still cannot reach outside the package.
-        "rootDir": ".."
+        "types": ["node"]
     },
     "include": ["src/**/*"],
     "exclude": ["node_modules", "dist"]