@nano133/nanoterra 0.1.0 → 0.3.0

package/dist/character/preview.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from "three";
+import type { LookRecord } from "./record.js";
+/** What draws one look: the game's own character dressed in it (its hat, its models), or by default the package's character. */
+export type PreviewBody<L> = {
+    object: THREE.Object3D;
+    /** Puts the look on. A promise waits (a model that loads). */
+    dress(look: L): void | Promise<void>;
+    /** Frees what the body made. */
+    dispose(): void;
+};
+export type LookPreviewOptions<L> = {
+    /** The picture's side in CSS pixels (default 112); it is drawn at twice that for a sharp screen. */
+    size?: number;
+    /** A body for the next picture. Left out: the package's character in `record` (else the island's first look), its shirt in the look's body colour. */
+    body?: () => PreviewBody<L>;
+    /** The record of the default body. */
+    record?: LookRecord;
+    /** The background (default: none, a clear picture). */
+    background?: THREE.ColorRepresentation | null;
+    /** The key of a look in the cache (default: its JSON text). */
+    key?: (look: L) => string;
+};
+export type LookPreview<L> = {
+    /** A PNG data URL of the look on the character, or null when the page has no WebGL or the drawing failed. */
+    render(look: L): Promise<string | null>;
+    /** How many pictures are kept. */
+    readonly cached: number;
+    /** Frees the renderer (and its WebGL context) and the cache. `render` answers null after it. */
+    dispose(): void;
+};
+/** A picture maker. Make one for a page and keep it: it holds one WebGL context while it lives. */
+export declare function createLookPreview<L>(options?: LookPreviewOptions<L>): LookPreview<L>;

package/dist/character/preview.js

@@ -0,0 +1,112 @@
+import * as THREE from "three";
+import { createCharacter } from "./create.js";
+function defaultBody(record) {
+    return () => {
+        const c = createCharacter({ record, reducedMotion: true });
+        return {
+            object: c.object,
+            dress(look) {
+                const body = look.change?.body;
+                if (body && (look.priceUsd ?? 1) > 0)
+                    c.setColors({ shirt: body });
+            },
+            dispose: () => c.dispose(),
+        };
+    };
+}
+/** A picture maker. Make one for a page and keep it: it holds one WebGL context while it lives. */
+export function createLookPreview(options = {}) {
+    const size = options.size ?? 112;
+    const makeBody = options.body ?? defaultBody(options.record);
+    const keyOf = options.key ?? ((l) => JSON.stringify(l));
+    const cache = new Map();
+    let renderer = null;
+    let failed = false;
+    let disposed = false;
+    let queue = Promise.resolve();
+    const scene = new THREE.Scene();
+    if (options.background != null)
+        scene.background = new THREE.Color(options.background);
+    scene.add(new THREE.HemisphereLight("#ffffff", "#8a8f9e", 1.6));
+    const sun = new THREE.DirectionalLight("#ffffff", 1.6);
+    sun.position.set(2, 4, 5);
+    scene.add(sun);
+    const camera = new THREE.PerspectiveCamera(30, 1, 0.05, 50);
+    function getRenderer() {
+        if (renderer || failed)
+            return renderer;
+        try {
+            // three makes its own canvas (in a page); with no page or no WebGL this throws, and the answer is null.
+            renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true, preserveDrawingBuffer: true });
+            renderer.setPixelRatio(1);
+            renderer.setSize(size * 2, size * 2, false);
+            renderer.setClearColor(0x000000, 0);
+        }
+        catch {
+            failed = true;
+            renderer = null;
+        }
+        return renderer;
+    }
+    async function draw(look) {
+        if (disposed)
+            return null;
+        const r = getRenderer();
+        if (!r)
+            return null;
+        const body = makeBody();
+        try {
+            await body.dress(look);
+            if (disposed)
+                return null;
+            scene.add(body.object);
+            // Frame the whole character (with what it holds) from the front, a little from its right and above.
+            body.object.updateMatrixWorld(true);
+            const box = new THREE.Box3().setFromObject(body.object);
+            const sphere = box.getBoundingSphere(new THREE.Sphere());
+            const dir = new THREE.Vector3(-0.6, 0.15, 1).normalize();
+            const dist = sphere.radius / Math.sin(THREE.MathUtils.degToRad(camera.fov / 2)) * 1.02;
+            camera.position.copy(sphere.center).addScaledVector(dir, dist);
+            camera.lookAt(sphere.center);
+            camera.near = Math.max(0.01, dist - sphere.radius * 2);
+            camera.far = dist + sphere.radius * 2;
+            camera.updateProjectionMatrix();
+            r.render(scene, camera);
+            return r.domElement.toDataURL("image/png");
+        }
+        catch {
+            return null;
+        }
+        finally {
+            scene.remove(body.object);
+            body.dispose();
+        }
+    }
+    return {
+        render(look) {
+            if (disposed)
+                return Promise.resolve(null);
+            const key = keyOf(look);
+            const hit = cache.get(key);
+            if (hit)
+                return hit;
+            // One at a time: the renderer and the scene are shared.
+            const p = queue.then(() => draw(look));
+            queue = p.catch(() => null);
+            cache.set(key, p);
+            return p;
+        },
+        get cached() {
+            return cache.size;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            cache.clear();
+            renderer?.dispose();
+            renderer?.forceContextLoss();
+            renderer = null;
+        },
+    };
+}

package/dist/character/sockets.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from "three";
+import type { BaseSpec } from "./bases/spec.js";
+import { BUILD_FACTORS } from "./make.js";
+import type { BoneName } from "./skeleton.js";
+/** The names of the sockets. */
+export declare const SOCKETS: readonly ["head", "hand", "back"];
+export type SocketName = (typeof SOCKETS)[number];
+/** Where a socket sits: its bone, and its place, turn and scale in that bone's space (the units of the character's own space). */
+export type SocketFrame = {
+    bone: BoneName;
+    position: THREE.Vector3;
+    quaternion: THREE.Quaternion;
+    scale: THREE.Vector3;
+};
+/**
+ * The hand's hold: a hand item is modelled standing up (+Y), its grip at the origin, its front at +Z. The hand holds it pointing forward,
+ * as a torch is held out: the item's +Y along the character's forward (+Z), its front (+Z) up, its +X to the character's right (-X).
+ */
+export declare const HAND_HOLD: Readonly<THREE.Quaternion>;
+/** What `socketFrame` reads of a look: its build and its head's size. */
+export type SocketLook = {
+    build: keyof typeof BUILD_FACTORS;
+    head: number;
+};
+/**
+ * A socket's frame on a base for a look.
+ *  - "head": on the head bone, at the base's hat frame (`spec.hat`), scaled by the hat frame and the head's size: a thing made for the
+ *    Classic's head, round the middle of the head (the game starter's hats are made so), fits every head.
+ *  - "hand": on grip_R, in the middle of the right hand (the hands of a wide body are drawn further out than their bone), turned by
+ *    `HAND_HOLD`.
+ *  - "back": on the chest bone, on the back of the torso (`spec.back`, else the chest's height and the torso's radius there); its axes are the
+ *    character's, so a back item is modelled with the side that touches the body at the origin and its bulk towards -Z.
+ */
+export declare function socketFrame(spec: BaseSpec, look: SocketLook, name: SocketName): SocketFrame;
+/** Puts a socket object on its bone (from `bones`) at its frame. The object keeps its children: a hung item moves with it. */
+export declare function placeSocket(socket: THREE.Object3D, bones: Partial<Record<BoneName, THREE.Object3D>>, spec: BaseSpec, look: SocketLook, name: SocketName): THREE.Object3D<THREE.Object3DEventMap>;
+export declare const isSocketName: (v: unknown) => v is SocketName;

package/dist/character/sockets.js

@@ -0,0 +1,66 @@
+import * as THREE from "three";
+import { BUILD_FACTORS } from "./make.js";
+// The character's three attach points (sockets): the head, the right hand and the back. A socket is a THREE.Object3D on one bone of the
+// island's skeleton, so a thing hung on it follows the walk, the run, the jump and the wave, and costs its own draws (a model of the game's,
+// a .glb say). A worn thing that is merged into the body's geometry (ctx.ts `WornAdapter.add`) adds no draw and needs no socket.
+//
+// Each socket's place depends on the base and on the look (the build widens the body and moves the hands out; the head's size scales the
+// head). `socketFrame` works it out; `createCharacter` keeps its sockets on the new bones after a rebuild (a new base, hair or clothes).
+/** The names of the sockets. */
+export const SOCKETS = ["head", "hand", "back"];
+/** The head bone's rest height. */
+const HEAD_BONE_Y = 1.5;
+/** The chest bone's rest height. */
+const CHEST_BONE_Y = 1.12;
+/**
+ * The hand's hold: a hand item is modelled standing up (+Y), its grip at the origin, its front at +Z. The hand holds it pointing forward,
+ * as a torch is held out: the item's +Y along the character's forward (+Z), its front (+Z) up, its +X to the character's right (-X).
+ */
+export const HAND_HOLD = Object.freeze(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 1).normalize(), Math.PI));
+/**
+ * A socket's frame on a base for a look.
+ *  - "head": on the head bone, at the base's hat frame (`spec.hat`), scaled by the hat frame and the head's size: a thing made for the
+ *    Classic's head, round the middle of the head (the game starter's hats are made so), fits every head.
+ *  - "hand": on grip_R, in the middle of the right hand (the hands of a wide body are drawn further out than their bone), turned by
+ *    `HAND_HOLD`.
+ *  - "back": on the chest bone, on the back of the torso (`spec.back`, else the chest's height and the torso's radius there); its axes are the
+ *    character's, so a back item is modelled with the side that touches the body at the origin and its bulk towards -Z.
+ */
+export function socketFrame(spec, look, name) {
+    const t = BUILD_FACTORS[look.build] ?? BUILD_FACTORS.regular;
+    const hs = look.head;
+    if (name === "head") {
+        const h = spec.hat;
+        return {
+            bone: "head",
+            position: new THREE.Vector3(0, (h.y - HEAD_BONE_Y) * hs, (h.z ?? 0) * hs),
+            quaternion: new THREE.Quaternion(),
+            scale: new THREE.Vector3(h.s[0] * hs, h.s[1] * hs, h.s[2] * hs),
+        };
+    }
+    if (name === "hand") {
+        // limbs.ts draws the hand at 0.47 + 0.45 (torso - 1) + armOut from the middle; the bone stays at 0.47.
+        const out = 0.45 * (t.torso - 1) + (spec.limbs.armOut ?? 0);
+        const at = spec.handAt ?? [0, 0, 0];
+        return { bone: "grip_R", position: new THREE.Vector3(-out + at[0], at[1], at[2]), quaternion: HAND_HOLD.clone(), scale: new THREE.Vector3(1, 1, 1) };
+    }
+    if (name === "back") {
+        const y = spec.back?.y ?? CHEST_BONE_Y;
+        const z = spec.back?.z ?? -spec.torsoR(y) * t.torso;
+        return { bone: "chest", position: new THREE.Vector3(0, y - CHEST_BONE_Y, z), quaternion: new THREE.Quaternion(), scale: new THREE.Vector3(1, 1, 1) };
+    }
+    throw new TypeError(`@nano133/nanoterra: there is no socket ${JSON.stringify(name)} (the sockets are ${SOCKETS.join(", ")})`);
+}
+/** Puts a socket object on its bone (from `bones`) at its frame. The object keeps its children: a hung item moves with it. */
+export function placeSocket(socket, bones, spec, look, name) {
+    const f = socketFrame(spec, look, name);
+    const bone = bones[f.bone];
+    if (!bone)
+        throw new TypeError(`@nano133/nanoterra: the skeleton has no bone ${f.bone} for the socket ${name}`);
+    socket.position.copy(f.position);
+    socket.quaternion.copy(f.quaternion);
+    socket.scale.copy(f.scale);
+    bone.add(socket);
+    return socket;
+}
+export const isSocketName = (v) => typeof v === "string" && SOCKETS.includes(v);

package/dist/looks/change.d.ts

@@ -1,14 +1,18 @@
-import type { Look, Problem } from "./look.js";
+import { type Look, type Problem, type Slots } from "./look.js";
+/** Whether two looks have the same slots: the same names with the same values, in any order. No slots and empty slots are the same; a colour is the same in upper and lower case. */
+export declare function sameSlots(a: Slots | undefined, b: Slots | undefined): boolean;
 /**
  * The mistakes that a new list would make for the players: an id that someone owns (a paid order gave it to them) is gone from the new
- * list. `owned` is every look id that any player owns. The free look is not owned by an order: it is every player's.
+ * list, or its slots changed (the game reads the slots of the id that a player owns, so a new slot changes what they own: add a new look instead).
+ * `owned` is every look id that any player owns. The free look is not owned by an order: it is every player's, and its slots may change.
+ * A change of a price, a name, a body colour or a hat on an owned look is allowed.
  */
 export declare function removalProblems(before: readonly Look[], after: readonly Look[], owned: Iterable<string>): Problem[];
-export type LookField = "name" | "priceUsd" | "body" | "hat" | "hatColor";
+export type LookField = "name" | "priceUsd" | "body" | "hat" | "hatColor" | "slots";
 export type LooksDiff = {
     added: Look[];
     removed: Look[];
-    /** Looks with the same id and a different name, price, colour or hat. */
+    /** Looks with the same id and a different name, price, colour, hat or slots. */
     changed: {
         id: string;
         before: Look;

package/dist/looks/change.js

@@ -1,16 +1,36 @@
+import { COLOR_PATTERN, cleanSlots } from "./look.js";
+/** Whether two looks have the same slots: the same names with the same values, in any order. No slots and empty slots are the same; a colour is the same in upper and lower case. */
+export function sameSlots(a, b) {
+    const x = cleanSlots(a) ?? {};
+    const y = cleanSlots(b) ?? {};
+    const names = Object.keys(x);
+    if (names.length !== Object.keys(y).length)
+        return false;
+    const norm = (v) => (COLOR_PATTERN.test(v) ? v.toLowerCase() : v);
+    return names.every((n) => Object.prototype.hasOwnProperty.call(y, n) && norm(x[n]) === norm(y[n]));
+}
 // What a change of the list does, before it goes live. Owned looks are stored by id: a look that someone owns must stay in the file.
 /**
  * The mistakes that a new list would make for the players: an id that someone owns (a paid order gave it to them) is gone from the new
- * list. `owned` is every look id that any player owns. The free look is not owned by an order: it is every player's.
+ * list, or its slots changed (the game reads the slots of the id that a player owns, so a new slot changes what they own: add a new look instead).
+ * `owned` is every look id that any player owns. The free look is not owned by an order: it is every player's, and its slots may change.
+ * A change of a price, a name, a body colour or a hat on an owned look is allowed.
  */
 export function removalProblems(before, after, owned) {
     const now = new Set(after.map((l) => l.id));
     const own = new Set(owned);
     const out = [];
+    const next = new Map(after.map((l, i) => [l.id, { look: l, place: i + 1 }]));
     for (const l of before) {
-        if (now.has(l.id) || !own.has(l.id))
+        if (!own.has(l.id))
             continue;
-        out.push({ look: null, field: "id", message: `The look "${l.id}" (${l.name}) is owned by a player and is not in the new list. Keep it in the file; change its price if you do not want to sell it.` });
+        const kept = next.get(l.id);
+        if (!kept) {
+            out.push({ look: null, field: "id", message: `The look "${l.id}" (${l.name}) is owned by a player and is not in the new list. Keep it in the file; change its price if you do not want to sell it.` });
+        }
+        else if (!sameSlots(l.slots, kept.look.slots)) {
+            out.push({ look: kept.place, field: "slots", message: `The slots of the look "${l.id}" (${l.name}) changed, and a player owns it. Keep its slots as they were, or add a new look with the new slots.` });
+        }
     }
     return out;
 }
@@ -34,6 +54,8 @@ export function diffLooks(before, after) {
             fields.push("hat");
         if ((a.change.hatColor ?? "").toLowerCase() !== (b.change.hatColor ?? "").toLowerCase())
             fields.push("hatColor");
+        if (!sameSlots(a.slots, b.slots))
+            fields.push("slots");
         if (fields.length)
             diff.changed.push({ id: a.id, before: b, after: a, fields });
     }

package/dist/looks/index.d.ts

@@ -1,7 +1,7 @@
-export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, PRICE_MAX_USD, wholeCents, lookProblems, checkLooks, usdText } from "./look.js";
-export type { Hat, Look, Problem } from "./look.js";
+export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, PRICE_MAX_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, lookProblems, checkLooks, cleanSlots, slotValueOk, usdText } from "./look.js";
+export type { Hat, Look, Problem, Slots } from "./look.js";
 export { PRICE_LADDER, rungUsd, rungOf, priceText } from "./ladder.js";
 export type { Rung } from "./ladder.js";
-export { removalProblems, diffLooks } from "./change.js";
+export { removalProblems, diffLooks, sameSlots } from "./change.js";
 export type { LooksDiff, LookField } from "./change.js";
 export { looksJson, slugId } from "./json.js";

package/dist/looks/index.js

@@ -1,4 +1,4 @@
-export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, PRICE_MAX_USD, wholeCents, lookProblems, checkLooks, usdText } from "./look.js";
+export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, PRICE_MAX_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, lookProblems, checkLooks, cleanSlots, slotValueOk, usdText } from "./look.js";
 export { PRICE_LADDER, rungUsd, rungOf, priceText } from "./ladder.js";
-export { removalProblems, diffLooks } from "./change.js";
+export { removalProblems, diffLooks, sameSlots } from "./change.js";
 export { looksJson, slugId } from "./json.js";

package/dist/looks/json.d.ts

@@ -1,7 +1,7 @@
 import { type Look } from "./look.js";
 /**
- * The text of looks.json for a list of looks: one look on each line, in the order id, name, priceUsd, change, as the game starter's
- * file is written, so a change of one look is a change of one line in a diff. It ends with a new line.
+ * The text of looks.json for a list of looks: one look on each line, in the order id, name, priceUsd, change (and slots, when the look has any), as the game
+ * starter's file is written, so a change of one look is a change of one line in a diff. A look with no slots is written exactly as before. It ends with a new line.
  */
 export declare function looksJson(looks: readonly Look[]): string;
 /** An id for a name: lowercase letters, digits and dashes, at most 40, and not one of `taken` ("mint-cap", then "mint-cap-2"). */

package/dist/looks/json.js

@@ -1,7 +1,7 @@
-import { ID_PATTERN } from "./look.js";
+import { cleanSlots, ID_PATTERN } from "./look.js";
 /**
- * The text of looks.json for a list of looks: one look on each line, in the order id, name, priceUsd, change, as the game starter's
- * file is written, so a change of one look is a change of one line in a diff. It ends with a new line.
+ * The text of looks.json for a list of looks: one look on each line, in the order id, name, priceUsd, change (and slots, when the look has any), as the game
+ * starter's file is written, so a change of one look is a change of one line in a diff. A look with no slots is written exactly as before. It ends with a new line.
  */
 export function looksJson(looks) {
     const row = (l) => {
@@ -10,7 +10,9 @@ export function looksJson(looks) {
             change.push(`"hat": ${JSON.stringify(l.change.hat)}`);
         if (l.change.hatColor !== undefined)
             change.push(`"hatColor": ${JSON.stringify(l.change.hatColor)}`);
-        return `  { "id": ${JSON.stringify(l.id)}, "name": ${JSON.stringify(l.name)}, "priceUsd": ${l.priceUsd}, "change": { ${change.join(", ")} } }`;
+        const slots = cleanSlots(l.slots);
+        const tail = slots ? `, "slots": { ${Object.keys(slots).map((k) => `${JSON.stringify(k)}: ${JSON.stringify(slots[k])}`).join(", ")} }` : "";
+        return `  { "id": ${JSON.stringify(l.id)}, "name": ${JSON.stringify(l.name)}, "priceUsd": ${l.priceUsd}, "change": { ${change.join(", ")} }${tail} }`;
     };
     return `[\n${looks.map(row).join(",\n")}\n]\n`;
 }

package/dist/looks/look.d.ts

@@ -13,24 +13,50 @@ export type Look = {
         hat?: Hat;
         hatColor?: string;
     };
+    /**
+     * What a game defines for itself: up to 8 slots, each a name and a value, that the game's own code reads ("wings": "ember", "trail": "#ffcf5a"). A name is 1 to 24
+     * lowercase letters, digits or dashes, starting with a letter; a value is a word (1 to 40 lowercase letters, digits or dashes) or a colour ("#rrggbb"). Optional: a look
+     * without `slots`, or with an empty one, is the same look. Because players own a look by its id, the slots of a look that someone owns must not change.
+     */
+    slots?: Slots;
 };
+/** The slots of a look: names and values, words or colours. */
+export type Slots = Record<string, string>;
 export declare const ID_PATTERN: RegExp;
 export declare const COLOR_PATTERN: RegExp;
+/** At most this many slots on a look. */
+export declare const SLOTS_MAX = 8;
+/** A slot's name: 1 to 24 lowercase letters, digits or dashes, starting with a letter. */
+export declare const SLOT_NAME_PATTERN: RegExp;
+/** Names that a slot may not have: they mean something to an object (`constructor`, `prototype`). */
+export declare const RESERVED_SLOT_NAMES: readonly string[];
+/** A slot's value that is a word: 1 to 40 lowercase letters, digits or dashes. (The other kind of value is a colour, COLOR_PATTERN.) */
+export declare const SLOT_WORD_PATTERN: RegExp;
 export declare const NAME_MAX = 40;
 export declare const PRICE_MAX_USD = 1000;
 /** One mistake in a list of looks. `message` says it in plain words, with where it is. */
 export type Problem = {
     /** The place of the look in the list, from 1, or null for a mistake of the whole list. */
     look: number | null;
-    /** The field: "list", "id", "name", "priceUsd", "change.body", "change.hat", "change.hatColor" or "free". */
+    /** The field: "list", "id", "name", "priceUsd", "change.body", "change.hat", "change.hatColor", "slots", "slots.<name>" or "free". (The change rules also use "slots" for a slot that changed on a look that players own.) */
     field: string;
     message: string;
 };
-/** Whether a price has no fraction of a cent. `Math.round(x * 100) === x * 100` is wrong for 0.07, 0.29 and 1.1 (floating point). */
+/**
+ * Whether a price has no fraction of a cent. `Math.round(x * 100) === x * 100` is wrong for 0.07, 0.29 and 1.1 (floating point), and a tolerance is wrong the other way (0.300000001
+ * and 1e-9 would pass): a price is whole cents when it is exactly the number that its own two-decimal text names.
+ */
 export declare function wholeCents(usd: number): boolean;
 /** Every mistake in a list of looks (looks.json as it was read), in the order of the list. An empty array means the list is good. */
 export declare function lookProblems(raw: unknown): Problem[];
+/** Whether a slot's value is good: a word or a colour. */
+export declare const slotValueOk: (v: unknown) => v is string;
+/**
+ * The slots as a clean copy, or undefined when there are none (an empty `slots` is the same as none). The creator's order of names is kept. A COLOUR is written in lower case
+ * ("#ffcf5a"), so the game always reads one text for one colour: a change of only the case of a colour is then no change at all, for the game as for the check.
+ */
+export declare function cleanSlots(slots: Slots | undefined): Slots | undefined;
 /** The looks, or an Error that says the first mistake in plain words. The same words as the starter's `checkLooks`. */
-export declare function checkLooks(raw: unknown): Look[];
+export declare function checkLooks(rawInput: unknown): Look[];
 /** "$0.25" */
 export declare const usdText: (usd: number) => string;

package/dist/looks/look.js

@@ -4,11 +4,22 @@
 export const HATS = ["cap", "beanie", "crown", "tophat"];
 export const ID_PATTERN = /^[a-z0-9-]{1,40}$/;
 export const COLOR_PATTERN = /^#[0-9a-f]{6}$/i;
+/** At most this many slots on a look. */
+export const SLOTS_MAX = 8;
+/** A slot's name: 1 to 24 lowercase letters, digits or dashes, starting with a letter. */
+export const SLOT_NAME_PATTERN = /^[a-z][a-z0-9-]{0,23}$/;
+/** Names that a slot may not have: they mean something to an object (`constructor`, `prototype`). */
+export const RESERVED_SLOT_NAMES = ["constructor", "prototype"];
+/** A slot's value that is a word: 1 to 40 lowercase letters, digits or dashes. (The other kind of value is a colour, COLOR_PATTERN.) */
+export const SLOT_WORD_PATTERN = /^[a-z0-9-]{1,40}$/;
 export const NAME_MAX = 40;
 export const PRICE_MAX_USD = 1000;
-/** Whether a price has no fraction of a cent. `Math.round(x * 100) === x * 100` is wrong for 0.07, 0.29 and 1.1 (floating point). */
+/**
+ * Whether a price has no fraction of a cent. `Math.round(x * 100) === x * 100` is wrong for 0.07, 0.29 and 1.1 (floating point), and a tolerance is wrong the other way (0.300000001
+ * and 1e-9 would pass): a price is whole cents when it is exactly the number that its own two-decimal text names.
+ */
 export function wholeCents(usd) {
-    return Math.abs(usd * 100 - Math.round(usd * 100)) < 1e-6;
+    return typeof usd === "number" && Number.isFinite(usd) && Number(usd.toFixed(2)) === usd;
 }
 /** Every mistake in a list of looks (looks.json as it was read), in the order of the list. An empty array means the list is good. */
 export function lookProblems(raw) {
@@ -41,17 +52,62 @@ export function lookProblems(raw) {
             add("change.hat", `"change.hat" must be one of ${HATS.join(", ")}`);
         if (v.change?.hatColor !== undefined && (typeof v.change.hatColor !== "string" || !COLOR_PATTERN.test(v.change.hatColor)))
             add("change.hatColor", '"change.hatColor" must be a colour like "#1c6e4f"');
+        if (v.slots !== undefined)
+            slotProblems(v.slots).forEach((s) => add(s.field, s.message));
     });
     if (!out.length && !free)
         out.push({ look: null, field: "free", message: "looks.json needs at least one free look (priceUsd 0): every player starts with it" });
     return out;
 }
+/** Whether `v` is a plain object (not null, not a list, not a class instance). */
+const isPlain = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+/** Whether a slot's value is good: a word or a colour. */
+export const slotValueOk = (v) => typeof v === "string" && (SLOT_WORD_PATTERN.test(v) || COLOR_PATTERN.test(v));
+/** The mistakes in one look's `slots` (the look's own message is added by the caller): the field is "slots" or "slots.<name>". */
+function slotProblems(slots) {
+    if (!isPlain(slots))
+        return [{ field: "slots", message: '"slots" must be an object of names and values, like { "wings": "ember" }' }];
+    const names = Object.keys(slots);
+    const out = [];
+    if (names.length > SLOTS_MAX)
+        out.push({ field: "slots", message: `"slots" can have at most ${SLOTS_MAX} slots (this one has ${names.length})` });
+    for (const name of names) {
+        if (!SLOT_NAME_PATTERN.test(name))
+            out.push({ field: `slots.${name}`, message: `the slot name "${name}" must be 1 to 24 lowercase letters, digits or dashes, starting with a letter` });
+        else if (RESERVED_SLOT_NAMES.includes(name))
+            out.push({ field: `slots.${name}`, message: `the slot name "${name}" is reserved: choose another` });
+        else if (!slotValueOk(slots[name]))
+            out.push({ field: `slots.${name}`, message: `"slots.${name}" must be a word (1 to 40 lowercase letters, digits or dashes) or a colour like "#ffcf5a"` });
+    }
+    return out;
+}
+/**
+ * The slots as a clean copy, or undefined when there are none (an empty `slots` is the same as none). The creator's order of names is kept. A COLOUR is written in lower case
+ * ("#ffcf5a"), so the game always reads one text for one colour: a change of only the case of a colour is then no change at all, for the game as for the check.
+ */
+export function cleanSlots(slots) {
+    if (!slots)
+        return undefined;
+    const names = Object.keys(slots);
+    return names.length ? Object.fromEntries(names.map((n) => [n, typeof slots[n] === "string" && COLOR_PATTERN.test(slots[n]) ? slots[n].toLowerCase() : slots[n]])) : undefined;
+}
 /** The looks, or an Error that says the first mistake in plain words. The same words as the starter's `checkLooks`. */
-export function checkLooks(raw) {
+export function checkLooks(rawInput) {
+    // One snapshot of the data is checked AND copied: a getter or a changing value cannot be good for the check and something else for the copy. (JSON cannot hold one.)
+    let raw = rawInput;
+    try {
+        raw = rawInput === undefined ? undefined : JSON.parse(JSON.stringify(rawInput));
+    }
+    catch {
+        throw new Error("looks.json must be plain JSON data");
+    }
     const first = lookProblems(raw)[0];
     if (first)
         throw new Error(first.message);
-    return raw.map((l) => ({ id: l.id, name: l.name, priceUsd: l.priceUsd, change: { body: l.change.body, hat: l.change.hat, hatColor: l.change.hatColor } }));
+    return raw.map((l) => {
+        const slots = cleanSlots(l.slots);
+        return { id: l.id, name: l.name, priceUsd: l.priceUsd, change: { body: l.change.body, hat: l.change.hat, hatColor: l.change.hatColor }, ...(slots ? { slots } : {}) };
+    });
 }
 /** "$0.25" */
 export const usdText = (usd) => `$${usd.toFixed(2)}`;

package/dist/model/check.d.ts

@@ -0,0 +1,59 @@
+import type { ModelLimits } from "./limits.js";
+export type ModelRule = "file" | "size" | "embedded" | "extensions" | "lights" | "motion" | "triangles" | "textures" | "draws" | "zone" | "markers" | "time";
+/** One thing wrong with the model: `fix` is one plain sentence or two, for the creator. */
+export type ModelProblem = {
+    rule: ModelRule;
+    fix: string;
+};
+export type Vec3 = [number, number, number];
+export type TextureFact = {
+    type: "image/png" | "image/jpeg" | "image/webp" | "image/ktx2";
+    width: number;
+    height: number;
+    bytes: number;
+};
+export type ModelFacts = {
+    bytes: number;
+    /** Triangles drawn (every instance counted; the `mesh` markers, as `nano_collide`, left out). Null when not counted. */
+    triangles: number | null;
+    textures: TextureFact[];
+    /**
+     * Draws: each part (glTF primitive) of each drawn mesh instance is one draw call, the `mesh` markers left out. Null when not counted.
+     * (A game may join parts or draw an ink outline; this counts the file as it is.)
+     */
+    draws: number | null;
+    /** The materials that the drawn parts use (a part with no material uses the default one, which counts once). */
+    materials: number;
+    /**
+     * The model's box in its own axes (metres), every drawn mesh and every `mesh` marker in it. Null when not measured. When the limits name an
+     * `anchor` and the file has it, the box, the reach and the zone are measured from the anchor's point (`anchor`), not the file's origin.
+     */
+    bounds: {
+        min: Vec3;
+        max: Vec3;
+    } | null;
+    /** The farthest drawn point from the y axis (x and z together, metres), the `mesh` markers in it. Null when not measured. */
+    reach: number | null;
+    /** True: the box and the reach come from every vertex. False: past the work cap, from each instance's box (larger, never smaller). */
+    exactBounds: boolean;
+    /** Where each marker that the file has stands (its node's origin, in the model's axes). */
+    markers: Record<string, Vec3>;
+    /** The anchor's point in the file's axes (the limits' `anchor` marker), or null: the file's origin is the attach point. */
+    anchor: Vec3 | null;
+    nodes: number;
+    meshes: number;
+    extensions: string[];
+};
+/** `advice`: plain lines that would make the model lighter (never a failure: `ok` does not read them). */
+export type ModelCheck = {
+    ok: boolean;
+    problems: ModelProblem[];
+    facts: ModelFacts;
+    advice: string[];
+};
+/** The picture's type and size from its bytes (never from the file's word for it), or null. */
+export declare function sniffTexture(b: Uint8Array): Omit<TextureFact, "bytes"> | null;
+/** Checks a .glb against `limits`. Never throws: a file that cannot be read answers a problem. */
+export declare function checkModel(input: Uint8Array, limits: ModelLimits): ModelCheck;
+/** One short line of what was measured: "12,000 triangles, 3 textures, 1.2 MB, 20.0 x 15.0 x 10.0 m". */
+export declare function modelSummary(f: ModelFacts): string;