@prosopo/puzzle-assets 0.1.4 → 0.2.0

package/src/palette.ts

@@ -1,110 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { Prng } from "./prng.js";
-
-export interface Rgb {
-	r: number;
-	g: number;
-	b: number;
-}
-
-/**
- * A background is built from analogous hues around a base, which is what keeps
- * the mesh gradients looking deliberate rather than muddy. Saturation and
- * lightness stay in a mid band: fully saturated colours make the notch's inner
- * shadow read as a colour shift rather than a depth cue, and very light or
- * very dark backgrounds flatten the piece against them.
- */
-interface PaletteSpec {
-	/** Base hue in degrees. */
-	hue: number;
-	/** How far the analogous hues may drift from the base, in degrees. */
-	spread: number;
-	saturation: [number, number];
-	lightness: [number, number];
-}
-
-const PALETTES: readonly PaletteSpec[] = [
-	// dusk violet
-	{ hue: 268, spread: 46, saturation: [0.55, 0.78], lightness: [0.4, 0.7] },
-	// prosopo blue
-	{ hue: 212, spread: 42, saturation: [0.58, 0.8], lightness: [0.4, 0.7] },
-	// teal drift
-	{ hue: 178, spread: 44, saturation: [0.5, 0.72], lightness: [0.38, 0.68] },
-	// warm sand
-	{ hue: 32, spread: 38, saturation: [0.58, 0.8], lightness: [0.45, 0.72] },
-	// rose quartz
-	{ hue: 338, spread: 40, saturation: [0.52, 0.74], lightness: [0.45, 0.72] },
-	// moss
-	{ hue: 138, spread: 42, saturation: [0.46, 0.66], lightness: [0.38, 0.66] },
-];
-
-const hueToChannel = (p: number, q: number, tRaw: number): number => {
-	let t = tRaw;
-	if (t < 0) t += 1;
-	if (t > 1) t -= 1;
-	if (t < 1 / 6) return p + (q - p) * 6 * t;
-	if (t < 1 / 2) return q;
-	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
-	return p;
-};
-
-/** h in degrees, s and l in [0, 1]. */
-export const hslToRgb = (h: number, s: number, l: number): Rgb => {
-	const hNorm = (((h % 360) + 360) % 360) / 360;
-	if (s === 0) {
-		const v = Math.round(l * 255);
-		return { r: v, g: v, b: v };
-	}
-	const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-	const p = 2 * l - q;
-	return {
-		r: Math.round(hueToChannel(p, q, hNorm + 1 / 3) * 255),
-		g: Math.round(hueToChannel(p, q, hNorm) * 255),
-		b: Math.round(hueToChannel(p, q, hNorm - 1 / 3) * 255),
-	};
-};
-
-/**
- * Draw `count` harmonious colours. The base hue is jittered per background so
- * two draws from the same palette are not the same picture.
- *
- * Hues are spread evenly across the band rather than sampled uniformly at
- * random, and lightness alternates between the ends of the range. Drawing both
- * at random clusters them: neighbouring control points come out nearly the same
- * colour and the mesh reads as one flat field with a slight gradient, which is
- * the difference between "designed" and "beige".
- */
-export const drawPalette = (prng: Prng, count: number): Rgb[] => {
-	const spec = prng.pick(PALETTES);
-	const baseHue = spec.hue + prng.range(-20, 20);
-	// Walk the hue band in a random direction so the light/dark alternation
-	// does not always run the same way around the wheel.
-	const direction = prng.next() < 0.5 ? -1 : 1;
-	const colours: Rgb[] = [];
-	for (let i = 0; i < count; i++) {
-		const t = count === 1 ? 0.5 : i / (count - 1);
-		const hue =
-			baseHue + direction * (t - 0.5) * 2 * spec.spread + prng.range(-6, 6);
-		const saturation = prng.range(spec.saturation[0], spec.saturation[1]);
-		// Alternate towards each end of the lightness range so adjacent fields
-		// contrast instead of averaging out.
-		const pole = i % 2 === 0 ? 0 : 1;
-		const lightness =
-			spec.lightness[pole] + prng.range(-0.04, 0.04) * (pole === 0 ? 1 : -1);
-		colours.push(hslToRgb(hue, saturation, lightness));
-	}
-	return colours;
-};

package/src/prng.ts

@@ -1,95 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { randomBytes } from "node:crypto";
-
-/**
- * Deterministic PRNG for background synthesis.
- *
- * SECURITY: the generator algorithm is public (this repo is open source), so
- * the seed is the ONLY thing standing between an attacker and a pixel-exact
- * reproduction of the clean background. Given the clean background they can
- * diff it against the composite they were served and read the notch position
- * straight off the difference. Seeds are therefore 128 bits from the system
- * CSPRNG and must never leave the provider — not in the response, not in logs,
- * not on the session record.
- */
-export interface Prng {
-	/** Uniform in [0, 1). */
-	next(): number;
-	/** Uniform integer in [min, max]. */
-	int(min: number, max: number): number;
-	/** Uniform in [min, max). */
-	range(min: number, max: number): number;
-	/** Uniform element of a non-empty list. */
-	pick<T>(items: readonly T[]): T;
-}
-
-export const SEED_BYTES = 16;
-
-/** Fresh 128-bit seed from the system CSPRNG. */
-export const createSeed = (): Buffer => randomBytes(SEED_BYTES);
-
-/**
- * xoshiro128** — small, fast, and good enough for imagery. Not a CSPRNG: the
- * secrecy of the output rests on the seed, which is.
- */
-export const createPrng = (seed: Buffer): Prng => {
-	if (seed.length < SEED_BYTES) {
-		throw new Error(
-			`puzzle-assets: seed must be at least ${SEED_BYTES} bytes, got ${seed.length}`,
-		);
-	}
-
-	let s0 = seed.readUInt32LE(0);
-	let s1 = seed.readUInt32LE(4);
-	let s2 = seed.readUInt32LE(8);
-	let s3 = seed.readUInt32LE(12);
-
-	// An all-zero state is a fixed point for xoshiro; nudge it.
-	if ((s0 | s1 | s2 | s3) === 0) {
-		s0 = 1;
-	}
-
-	const rotl = (x: number, k: number): number =>
-		((x << k) | (x >>> (32 - k))) >>> 0;
-
-	const nextUint32 = (): number => {
-		const result = (Math.imul(rotl(Math.imul(s1, 5) >>> 0, 7), 9) >>> 0) >>> 0;
-		const t = (s1 << 9) >>> 0;
-		s2 = (s2 ^ s0) >>> 0;
-		s3 = (s3 ^ s1) >>> 0;
-		s1 = (s1 ^ s2) >>> 0;
-		s0 = (s0 ^ s3) >>> 0;
-		s2 = (s2 ^ t) >>> 0;
-		s3 = rotl(s3, 11);
-		return result;
-	};
-
-	const next = (): number => nextUint32() / 4294967296;
-
-	return {
-		next,
-		int: (min: number, max: number): number =>
-			min + Math.floor(next() * (max - min + 1)),
-		range: (min: number, max: number): number => min + next() * (max - min),
-		pick: <T>(items: readonly T[]): T => {
-			const item = items[Math.floor(next() * items.length)];
-			if (item === undefined) {
-				throw new Error("puzzle-assets: cannot pick from an empty list");
-			}
-			return item;
-		},
-	};
-};

package/src/tests/puzzleAssets.unit.test.ts

@@ -1,438 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { describe, expect, it } from "vitest";
-import { generateBackground } from "../background.js";
-import { cutNotch } from "../compose.js";
-import { paintDecoyPiece, paintDecoys } from "../decoys.js";
-import {
-	DEFAULT_GEOMETRY,
-	DEFAULT_RENDER_SETTINGS,
-	createBackground,
-	renderPuzzle,
-} from "../index.js";
-import { coverageFromDistance, createNotchShape } from "../notch.js";
-import { createPrng, createSeed } from "../prng.js";
-import type { RgbaImage } from "../types.js";
-
-const SEED_A = Buffer.from("0123456789abcdef", "utf-8");
-const SEED_B = Buffer.from("fedcba9876543210", "utf-8");
-
-const meanLuma = (image: RgbaImage): number => {
-	let total = 0;
-	const pixels = image.width * image.height;
-	for (let i = 0; i < pixels; i++) {
-		const o = i * 4;
-		total +=
-			0.299 * (image.data[o] ?? 0) +
-			0.587 * (image.data[o + 1] ?? 0) +
-			0.114 * (image.data[o + 2] ?? 0);
-	}
-	return total / pixels;
-};
-
-describe("prng", () => {
-	it("is deterministic for a given seed", () => {
-		const a = createPrng(SEED_A);
-		const b = createPrng(SEED_A);
-		const drawA = [a.next(), a.next(), a.next()];
-		const drawB = [b.next(), b.next(), b.next()];
-		expect(drawA).toEqual(drawB);
-	});
-
-	it("diverges for different seeds", () => {
-		const a = createPrng(SEED_A);
-		const b = createPrng(SEED_B);
-		expect(a.next()).not.toBe(b.next());
-	});
-
-	it("stays within bounds", () => {
-		const prng = createPrng(SEED_A);
-		for (let i = 0; i < 500; i++) {
-			const v = prng.next();
-			expect(v).toBeGreaterThanOrEqual(0);
-			expect(v).toBeLessThan(1);
-			const n = prng.int(3, 7);
-			expect(n).toBeGreaterThanOrEqual(3);
-			expect(n).toBeLessThanOrEqual(7);
-		}
-	});
-
-	it("rejects a seed shorter than 128 bits", () => {
-		expect(() => createPrng(Buffer.alloc(8))).toThrow(/seed must be at least/);
-	});
-
-	it("issues 128-bit seeds", () => {
-		expect(createSeed()).toHaveLength(16);
-		// Two seeds colliding would mean the CSPRNG is broken; the whole design
-		// rests on an attacker being unable to reproduce the clean background.
-		expect(createSeed().equals(createSeed())).toBe(false);
-	});
-});
-
-describe("generateBackground", () => {
-	it("fills every pixel opaque", () => {
-		const image = generateBackground(createPrng(SEED_A), 60, 40);
-		expect(image.data).toHaveLength(60 * 40 * 4);
-		for (let i = 0; i < 60 * 40; i++) {
-			expect(image.data[i * 4 + 3]).toBe(255);
-		}
-	});
-
-	it("is reproducible from its seed", () => {
-		const a = generateBackground(createPrng(SEED_A), 60, 40);
-		const b = generateBackground(createPrng(SEED_A), 60, 40);
-		expect(a.data.equals(b.data)).toBe(true);
-	});
-
-	it("produces a different picture for a different seed", () => {
-		const a = generateBackground(createPrng(SEED_A), 60, 40);
-		const b = generateBackground(createPrng(SEED_B), 60, 40);
-		expect(a.data.equals(b.data)).toBe(false);
-	});
-
-	it("is not a flat wash", () => {
-		// Guards the regression that made every pixel converge on the palette
-		// mean: with too-broad falloff the frame came out a single flat colour.
-		const image = generateBackground(createPrng(SEED_A), 300, 200);
-		let min = 255;
-		let max = 0;
-		for (let i = 0; i < image.width * image.height; i++) {
-			const o = i * 4;
-			const luma =
-				0.299 * (image.data[o] ?? 0) +
-				0.587 * (image.data[o + 1] ?? 0) +
-				0.114 * (image.data[o + 2] ?? 0);
-			min = Math.min(min, luma);
-			max = Math.max(max, luma);
-		}
-		expect(max - min).toBeGreaterThan(25);
-	});
-});
-
-describe("cutNotch", () => {
-	const geometry = DEFAULT_GEOMETRY;
-	const placement = { targetX: 200, targetY: 100 };
-
-	it("darkens the hole and leaves the rest of the frame alone", () => {
-		const prng = createPrng(SEED_A);
-		const original = generateBackground(
-			createPrng(SEED_A),
-			geometry.width,
-			geometry.height,
-		);
-		const working = generateBackground(
-			createPrng(SEED_A),
-			geometry.width,
-			geometry.height,
-		);
-		const shape = createNotchShape(prng, geometry.notchSize);
-		const { background, piece } = cutNotch(
-			prng,
-			working,
-			shape,
-			geometry.notchSize,
-			placement,
-			DEFAULT_RENDER_SETTINGS.holeDarken,
-		);
-
-		// Centre of the notch is darker than it was.
-		const centre = (placement.targetY * geometry.width + placement.targetX) * 4;
-		expect(background.data[centre]).toBeLessThan(original.data[centre] ?? 255);
-
-		// A pixel far from the cut is untouched.
-		const far = (10 * geometry.width + 10) * 4;
-		expect(background.data[far]).toBe(original.data[far]);
-
-		expect(piece.width).toBe(geometry.notchSize);
-		expect(piece.height).toBe(geometry.notchSize);
-	});
-
-	it("makes the piece opaque inside the shape and transparent at the corners", () => {
-		const prng = createPrng(SEED_A);
-		const background = createBackground(geometry);
-		const shape = createNotchShape(prng, geometry.notchSize);
-		const { piece } = cutNotch(
-			prng,
-			background,
-			shape,
-			geometry.notchSize,
-			placement,
-			DEFAULT_RENDER_SETTINGS.holeDarken,
-		);
-
-		const half = Math.floor(geometry.notchSize / 2);
-		const centreAlpha =
-			piece.data[(half * geometry.notchSize + half) * 4 + 3] ?? 0;
-		expect(centreAlpha).toBe(255);
-
-		// Corners sit outside a rounded silhouette. The drop shadow may tint
-		// them slightly, so this asserts "not solid", not "fully clear".
-		expect(piece.data[3] ?? 255).toBeLessThan(128);
-	});
-
-	it("clips the piece to transparent where the placement overhangs the frame", () => {
-		// Place the notch centred on the top-right corner: roughly a
-		// quarter of the bounding box sits inside the frame; the rest
-		// hangs off. Every piece pixel outside the frame must be
-		// transparent — the sampler no longer clamps to the edge.
-		const prng = createPrng(SEED_A);
-		const bg = createBackground(geometry);
-		const shape = createNotchShape(prng, geometry.notchSize);
-		const overhangPlacement = {
-			targetX: geometry.width,
-			targetY: 0,
-		};
-		const { piece } = cutNotch(
-			prng,
-			bg,
-			shape,
-			geometry.notchSize,
-			overhangPlacement,
-			DEFAULT_RENDER_SETTINGS.holeDarken,
-		);
-
-		const half = geometry.notchSize / 2;
-		const left = Math.round(overhangPlacement.targetX - half);
-		const top = Math.round(overhangPlacement.targetY - half);
-		let outOfFrameOpaque = 0;
-		for (let ly = 0; ly < geometry.notchSize; ly++) {
-			for (let lx = 0; lx < geometry.notchSize; lx++) {
-				const bx = left + lx;
-				const by = top + ly;
-				const inFrame =
-					bx >= 0 && by >= 0 && bx < geometry.width && by < geometry.height;
-				if (inFrame) continue;
-				const alpha = piece.data[(ly * geometry.notchSize + lx) * 4 + 3] ?? 0;
-				if (alpha !== 0) outOfFrameOpaque++;
-			}
-		}
-		expect(outOfFrameOpaque).toBe(0);
-	});
-
-	it("does not reproduce the background pixel-exactly in the piece", () => {
-		// The anti-correlation defence: an exact copy would let an attacker
-		// locate the target by sliding the piece over the background.
-		const prng = createPrng(SEED_A);
-		const reference = generateBackground(
-			createPrng(SEED_A),
-			geometry.width,
-			geometry.height,
-		);
-		const working = generateBackground(
-			createPrng(SEED_A),
-			geometry.width,
-			geometry.height,
-		);
-		const shape = createNotchShape(prng, geometry.notchSize);
-		const { piece } = cutNotch(
-			prng,
-			working,
-			shape,
-			geometry.notchSize,
-			placement,
-			DEFAULT_RENDER_SETTINGS.holeDarken,
-		);
-
-		const half = geometry.notchSize / 2;
-		const left = Math.round(placement.targetX - half);
-		const top = Math.round(placement.targetY - half);
-		let identical = 0;
-		let compared = 0;
-		for (let ly = 0; ly < geometry.notchSize; ly++) {
-			for (let lx = 0; lx < geometry.notchSize; lx++) {
-				const pi = (ly * geometry.notchSize + lx) * 4;
-				if ((piece.data[pi + 3] ?? 0) < 255) continue;
-				const bi = ((top + ly) * geometry.width + (left + lx)) * 4;
-				compared++;
-				if (piece.data[pi] === reference.data[bi]) identical++;
-			}
-		}
-		expect(compared).toBeGreaterThan(100);
-		expect(identical / compared).toBeLessThan(0.5);
-	});
-});
-
-describe("renderPuzzle", () => {
-	it("encodes both halves as webp", async () => {
-		const rendered = await renderPuzzle(createBackground(), {
-			targetX: 200,
-			targetY: 100,
-		});
-		// RIFF....WEBP
-		expect(rendered.background.subarray(0, 4).toString("ascii")).toBe("RIFF");
-		expect(rendered.background.subarray(8, 12).toString("ascii")).toBe("WEBP");
-		expect(rendered.piece.subarray(8, 12).toString("ascii")).toBe("WEBP");
-		expect(rendered.pieceSize).toBe(DEFAULT_GEOMETRY.notchSize);
-	});
-
-	it("honors a `pieceSize` override independently of `notchSize`", async () => {
-		const overrideSize = 180;
-		const rendered = await renderPuzzle(
-			createBackground(),
-			{ targetX: 150, targetY: 100 },
-			{ ...DEFAULT_GEOMETRY, pieceSize: overrideSize },
-		);
-		expect(rendered.pieceSize).toBe(overrideSize);
-	});
-
-	it("stays small enough to inline as a data uri", async () => {
-		const rendered = await renderPuzzle(createBackground(), {
-			targetX: 200,
-			targetY: 100,
-		});
-		const base64Bytes =
-			Math.ceil(rendered.background.length / 3) * 4 +
-			Math.ceil(rendered.piece.length / 3) * 4;
-		expect(base64Bytes).toBeLessThan(120_000);
-	});
-});
-
-describe("coverageFromDistance", () => {
-	it("is 1 well inside, 0 well outside and partial on the boundary", () => {
-		expect(coverageFromDistance(-5)).toBe(1);
-		expect(coverageFromDistance(5)).toBe(0);
-		const edge = coverageFromDistance(0);
-		expect(edge).toBeGreaterThan(0);
-		expect(edge).toBeLessThan(1);
-	});
-});
-
-describe("background brightness", () => {
-	it("keeps a usable mid-range so the piece stays visible", () => {
-		for (const seed of [SEED_A, SEED_B]) {
-			const luma = meanLuma(generateBackground(createPrng(seed), 300, 200));
-			expect(luma).toBeGreaterThan(60);
-			expect(luma).toBeLessThan(215);
-		}
-	});
-});
-
-describe("paintDecoys", () => {
-	const notch = { targetX: 220, targetY: 140 };
-	const { decoyEdgeDarkness, decoyBodyBrightness, decoyHoleDarken } =
-		DEFAULT_RENDER_SETTINGS;
-
-	it("is a no-op for count <= 0", () => {
-		const bg = generateBackground(createPrng(SEED_A), 300, 200);
-		const before = Buffer.from(bg.data);
-		paintDecoys(
-			bg,
-			createPrng(SEED_A),
-			0,
-			DEFAULT_GEOMETRY.notchSize,
-			notch,
-			decoyEdgeDarkness,
-			decoyBodyBrightness,
-			decoyHoleDarken,
-		);
-		expect(bg.data.equals(before)).toBe(true);
-	});
-
-	it("mutates the background when count > 0", () => {
-		const bg = generateBackground(createPrng(SEED_A), 300, 200);
-		const before = Buffer.from(bg.data);
-		paintDecoys(
-			bg,
-			createPrng(SEED_B),
-			3,
-			DEFAULT_GEOMETRY.notchSize,
-			notch,
-			decoyEdgeDarkness,
-			decoyBodyBrightness,
-			decoyHoleDarken,
-		);
-		expect(bg.data.equals(before)).toBe(false);
-	});
-
-	it("is deterministic for a given prng seed", () => {
-		const bg1 = generateBackground(createPrng(SEED_A), 300, 200);
-		const bg2 = generateBackground(createPrng(SEED_A), 300, 200);
-		paintDecoys(
-			bg1,
-			createPrng(SEED_B),
-			3,
-			DEFAULT_GEOMETRY.notchSize,
-			notch,
-			decoyEdgeDarkness,
-			decoyBodyBrightness,
-			decoyHoleDarken,
-		);
-		paintDecoys(
-			bg2,
-			createPrng(SEED_B),
-			3,
-			DEFAULT_GEOMETRY.notchSize,
-			notch,
-			decoyEdgeDarkness,
-			decoyBodyBrightness,
-			decoyHoleDarken,
-		);
-		expect(bg1.data.equals(bg2.data)).toBe(true);
-	});
-
-	// holeDarken == 0 collapses every decoy body to full black in the
-	// interior. Guards the multiplicative path — a regression that reverts
-	// decoys to the pre-hole-darken additive shift only would still tint the
-	// pixels but never reach zero. Uses `paintDecoyPiece` directly so the
-	// centre pixel is deterministic (`paintDecoys` scatters randomly).
-	it("blackens the decoy interior when holeDarken is zero", () => {
-		const bg = generateBackground(createPrng(SEED_A), 300, 200);
-		const cx = 150;
-		const cy = 100;
-		// Additive rim/body knobs at 0 too so only the multiplicative path
-		// contributes; otherwise `bodyBrightness` adds back a few units and
-		// the pixels never reach exactly zero.
-		paintDecoyPiece(
-			bg,
-			createPrng(SEED_B),
-			DEFAULT_GEOMETRY.notchSize,
-			cx,
-			cy,
-			0,
-			0,
-			0,
-		);
-		const i = (cy * bg.width + cx) * 4;
-		expect(bg.data[i]).toBe(0);
-		expect(bg.data[i + 1]).toBe(0);
-		expect(bg.data[i + 2]).toBe(0);
-	});
-});
-
-describe("renderPuzzle with decoys", () => {
-	it("still returns a matching piece when decoys are present", async () => {
-		const bg = createBackground(DEFAULT_GEOMETRY);
-		const rendered = await renderPuzzle(
-			bg,
-			{ targetX: 150, targetY: 100 },
-			DEFAULT_GEOMETRY,
-			{ ...DEFAULT_RENDER_SETTINGS, decoyCount: 3 },
-		);
-		expect(rendered.background.length).toBeGreaterThan(0);
-		expect(rendered.piece.length).toBeGreaterThan(0);
-		expect(rendered.pieceSize).toBe(DEFAULT_GEOMETRY.notchSize);
-	});
-
-	it("honors decoyCount 0 (no decoys) end-to-end", async () => {
-		const target = { targetX: 150, targetY: 100 };
-		const rendered = await renderPuzzle(
-			createBackground(DEFAULT_GEOMETRY),
-			target,
-			DEFAULT_GEOMETRY,
-			{ ...DEFAULT_RENDER_SETTINGS, decoyCount: 0 },
-		);
-		expect(rendered.background.length).toBeGreaterThan(0);
-	});
-});