@nano133/nanoterra 0.1.0 → 0.2.0

package/dist/admin/panel/signins.js

@@ -0,0 +1,69 @@
+// The "Sign-ins" card of /admin: the last admin sign-ins (when, the rough country, a short browser name) and "Sign out everywhere". It shows only what the store gave for a
+// sign-in: the three things of `AdminLogin`. The sign-out is two presses, so that one slip does not end every login.
+import { ApiError } from "./api.js";
+import { h } from "./dom.js";
+/** What the card says about what is kept, unless the game says its own (its retention). */
+export const DEFAULT_LOGINS_NOTE = "For each sign-in only the time, the rough country and a short browser name are kept: no address and no full browser text.";
+/** "United States (US)", or "US" when the name is not known, or "unknown country". */
+function countryText(code) {
+    if (!code)
+        return "unknown country";
+    try {
+        const name = new Intl.DisplayNames(["en"], { type: "region" }).of(code);
+        return name && name !== code ? `${name} (${code})` : code;
+    }
+    catch {
+        return code;
+    }
+}
+/** The card, or null when the store lists no sign-ins and cannot sign out. `done` runs after a sign-out everywhere (the panel loads again and asks for a sign-in). */
+export function signinsCard(s, api, done, note = DEFAULT_LOGINS_NOTE) {
+    if (!s.logins && !s.canSignOutEverywhere)
+        return null;
+    const card = h("section", { class: "admin-card signins", "aria-labelledby": "signins-title" }, h("h2", { id: "signins-title" }, "Sign-ins"));
+    if (s.logins) {
+        card.append(h("p", { class: "fine" }, "The last sign-ins to this admin, newest first. If one is not yours, press Sign out everywhere."));
+        const list = h("ul", { class: "signin-list" });
+        for (const l of s.logins)
+            list.append(h("li", {}, h("strong", {}, new Date(l.at).toLocaleString()), h("span", {}, ` · ${countryText(l.country)} · ${l.browser}`)));
+        if (!s.logins.length)
+            list.append(h("li", { class: "fine" }, "No sign-in is listed yet."));
+        card.append(list, h("p", { class: "fine" }, note));
+    }
+    if (s.canSignOutEverywhere) {
+        const box = h("div", { class: "signout-box" });
+        const status = h("span", { class: "fine", role: "status" });
+        const first = h("button", { class: "btn", type: "button" }, "Sign out everywhere");
+        const confirm = h("div", { class: "signout-confirm" });
+        confirm.hidden = true;
+        const yes = h("button", { class: "btn btn-primary", type: "button" }, "Yes, sign out everywhere");
+        const cancel = h("button", { class: "btn", type: "button" }, "Cancel");
+        confirm.append(h("p", {}, "This ends every admin sign-in, in every browser, this one too. You will sign in again."), yes, " ", cancel);
+        first.addEventListener("click", () => {
+            first.hidden = true;
+            confirm.hidden = false;
+            status.textContent = "";
+        });
+        cancel.addEventListener("click", () => {
+            confirm.hidden = true;
+            first.hidden = false;
+        });
+        yes.addEventListener("click", async () => {
+            yes.disabled = true;
+            cancel.disabled = true;
+            status.textContent = "Signing out…";
+            try {
+                await api.post("/signout-all");
+                done();
+            }
+            catch (e) {
+                status.textContent = e instanceof ApiError ? e.message : "The game's server did not answer. Nothing was changed.";
+                yes.disabled = false;
+                cancel.disabled = false;
+            }
+        });
+        box.append(first, confirm, status);
+        card.append(box);
+    }
+    return card;
+}

package/dist/admin/store.d.ts

@@ -0,0 +1,121 @@
+import type { GamePatch } from "./switches.js";
+/** Money as the admin page shows it: a count, the XNO text and the US dollars as text. */
+export type Money = {
+    count: number;
+    xno: string;
+    usd: string;
+};
+export type OrderStatus = "open" | "paid" | "expired" | "paid_late";
+export type AdminOrder = {
+    id: string;
+    /** The player's Nano address. */
+    player: string;
+    lookId: string;
+    /** What the player reads for the look (the handler fills it from `lookName`). */
+    look: string;
+    usd: string;
+    xno: string;
+    status: OrderStatus | string;
+    createdAt: number;
+    expiresAt: number;
+    paidAt: number | null;
+    payer: string | null;
+    hash: string | null;
+};
+export type AdminPlayer = {
+    player: string;
+    looks: {
+        id: string;
+        name: string;
+        at: number;
+    }[];
+};
+/** The numbers of the orders and the looks that players own. */
+export type StoreSummary = {
+    counts: {
+        open: number;
+        paid: number;
+        expired: number;
+        paid_late: number;
+    };
+    totals: {
+        paid: Money;
+        paidLate: Money;
+    };
+    /** Newest first, at most 500. `look` is filled by the handler. */
+    orders: Omit<AdminOrder, "look">[];
+    /** Players and the looks that a paid order gave them. `name` is filled by the handler. */
+    players: {
+        player: string;
+        looks: {
+            id: string;
+            at: number;
+        }[];
+    }[];
+    /** The price of XNO in US dollars that the game uses, and where it came from. */
+    rate: {
+        usd: number;
+        sources: string[];
+        at: number;
+    } | null;
+};
+/**
+ * One admin sign-in, as the panel lists it: when, the rough country (two letters, or null when the game did not know it) and a short browser name ("Chrome on macOS").
+ * Nothing else: no address, no IP, no browser text. The game writes these when it makes an admin login; the package only reads them.
+ */
+export type AdminLogin = {
+    at: number;
+    country: string | null;
+    browser: string;
+};
+/** How many sign-ins the panel lists. */
+export declare const ADMIN_LOGINS_SHOWN = 10;
+/**
+ * The game's database, as the handler needs it. An adapter writes ONLY what these calls say: the two settings and, when the game turns it on, the deletion of the admin sessions
+ * (`signOutEverywhere`). Nothing else.
+ * (There is no call that writes a look, a price or an order: the Shelf gives text to copy, and a change of looks is a change of the repository.)
+ */
+export interface AdminStore {
+    /** The settings that /admin has saved. A value that is not a known word is ignored by the handler, so an adapter returns what it holds. */
+    readSettings(): Promise<{
+        character?: unknown;
+        signin?: unknown;
+    }>;
+    /** Saves a checked patch: all of it or none of it. */
+    saveSettings(patch: GamePatch, now: number): Promise<void>;
+    summary(now: number): Promise<StoreSummary>;
+    /**
+     * Optional. The last sign-ins to the admin, newest first, at most `limit`, with only the three things of `AdminLogin`. With it the summary lists them (the "Sign-ins" card).
+     * An adapter that has it must never return more than those three things for a sign-in.
+     */
+    recentLogins?(limit: number): Promise<AdminLogin[]>;
+    /**
+     * Optional. Deletes EVERY admin session (the admin login of the owner, in every browser, this one too) and no other session; returns how many it deleted. With it the handler has
+     * the route `POST {base}/signout-all` and the panel has "Sign out everywhere". An adapter must delete only sessions of the ADMIN scope.
+     */
+    signOutEverywhere?(): Promise<number>;
+}
+/** What the game says about itself on the Status card: only the game knows its address, its test mode and what is still off. */
+export type AdminStatus = {
+    address: string | null;
+    testMode: boolean;
+    /** Whether Turnstile (the bot check) is on. */
+    turnstile?: boolean;
+    /** The names of the Nano nodes that check payments. */
+    nodes?: string[];
+    /** "owner/repo" on GitHub, for the link to looks.json. */
+    repo?: string | null;
+    /** Plain sentences about what is still off. */
+    warnings: string[];
+};
+/** The whole of GET summary. */
+export type AdminSummary = AdminStatus & Omit<StoreSummary, "orders" | "players"> & {
+    orders: AdminOrder[];
+    players: AdminPlayer[];
+    /** Whether the game gave a payment check (POST check). The panel shows "Check payments now" only then. */
+    canCheck: boolean;
+    /** The last admin sign-ins (newest first), when the store can list them. */
+    logins?: AdminLogin[];
+    /** Whether the route "sign out everywhere" exists (the store can do it). */
+    canSignOutEverywhere?: boolean;
+};

package/dist/admin/store.js

@@ -0,0 +1,3 @@
+// What a game gives the admin handler: a store (an adapter for its database) and a status. The package has no database of its own.
+/** How many sign-ins the panel lists. */
+export const ADMIN_LOGINS_SHOWN = 10;

package/dist/admin/summary.d.ts

@@ -0,0 +1,39 @@
+import type { AdminOrder, Money, StoreSummary } from "./store.js";
+/** An order as an adapter reads it: the amount is the raw amount (digits), the times are ms. */
+export type OrderRow = {
+    id: string;
+    player: string;
+    lookId: string;
+    usd: string;
+    amountRaw: string;
+    status: string;
+    createdAt: number;
+    expiresAt: number;
+    paidAt: number | null;
+    payer: string | null;
+    hash: string | null;
+};
+export declare const ORDERS_SHOWN = 500;
+/** Money from rows that are all of one status: the count, the XNO text of the raw sum and the dollars (summed in cents, so 0.1 + 0.2 is 0.30). */
+export declare function moneyOf(rows: readonly {
+    amountRaw: string;
+    usd: string;
+}[]): Money;
+/** Where an order counts: an open order past its expiry counts as expired. */
+export declare const statusOf: (status: string, expiresAt: number, now: number) => string;
+/** The orders as the page lists them: newest first, at most ORDERS_SHOWN, an open one past its expiry read as "expired". */
+export declare function shapeOrders(rows: readonly OrderRow[], now: number): Omit<AdminOrder, "look">[];
+/** The looks that players own, by player (players and their looks in a steady order). */
+export declare function shapePlayers(owned: readonly {
+    player: string;
+    lookId: string;
+    at: number;
+}[]): StoreSummary["players"];
+/** The whole summary from ALL the rows (for a store that reads the rows itself: Firestore, memory). */
+export declare function summarize(rows: readonly OrderRow[], owned: readonly {
+    player: string;
+    lookId: string;
+    at: number;
+}[], rate: StoreSummary["rate"], now: number): StoreSummary;
+/** The `rate` row of the meta table: JSON { usd, sources } kept with the time. Anything that is not that is no rate. */
+export declare function parseRate(value: unknown, at: unknown): StoreSummary["rate"];

package/dist/admin/summary.js

@@ -0,0 +1,85 @@
+// The numbers of the summary from the rows of the orders, the same for every adapter: the counts by status, the totals and the shape of an order.
+// An adapter reads its rows; this file turns them into a `StoreSummary`.
+import { isRawText, xnoText } from "./amount.js";
+export const ORDERS_SHOWN = 500;
+/** Cents from a dollar text like "0.25". Anything that is not plain dollars (a sign, an exponent, hex) counts as 0: a bad row must not change a total. */
+const toCents = (usd) => {
+    if (typeof usd !== "string" || !/^\d{1,9}(\.\d{1,8})?$/.test(usd))
+        return 0;
+    return Math.round(Number(usd) * 100);
+};
+/** Money from rows that are all of one status: the count, the XNO text of the raw sum and the dollars (summed in cents, so 0.1 + 0.2 is 0.30). */
+export function moneyOf(rows) {
+    let raw = 0n;
+    let cents = 0;
+    for (const r of rows) {
+        if (isRawText(r.amountRaw))
+            raw += BigInt(r.amountRaw);
+        cents += toCents(r.usd);
+    }
+    return { count: rows.length, xno: xnoText(raw.toString()), usd: (cents / 100).toFixed(2) };
+}
+/** Where an order counts: an open order past its expiry counts as expired. */
+export const statusOf = (status, expiresAt, now) => (status === "open" && expiresAt < now ? "expired" : status);
+/** The orders as the page lists them: newest first, at most ORDERS_SHOWN, an open one past its expiry read as "expired". */
+export function shapeOrders(rows, now) {
+    return [...rows]
+        .sort((a, b) => b.createdAt - a.createdAt || (a.id < b.id ? -1 : 1))
+        .slice(0, ORDERS_SHOWN)
+        .map((o) => ({
+        id: o.id,
+        player: o.player,
+        lookId: o.lookId,
+        usd: o.usd,
+        xno: isRawText(o.amountRaw) ? xnoText(o.amountRaw) : "0",
+        status: statusOf(o.status, o.expiresAt, now),
+        createdAt: o.createdAt,
+        expiresAt: o.expiresAt,
+        paidAt: o.paidAt,
+        payer: o.payer,
+        hash: o.hash,
+    }));
+}
+/** The looks that players own, by player (players and their looks in a steady order). */
+export function shapePlayers(owned) {
+    const players = new Map();
+    for (const o of [...owned].sort((a, b) => (a.player < b.player ? -1 : a.player > b.player ? 1 : a.at - b.at))) {
+        const p = players.get(o.player) ?? { player: o.player, looks: [] };
+        p.looks.push({ id: o.lookId, at: o.at });
+        players.set(o.player, p);
+    }
+    return [...players.values()];
+}
+/** The whole summary from ALL the rows (for a store that reads the rows itself: Firestore, memory). */
+export function summarize(rows, owned, rate, now) {
+    const counts = { open: 0, paid: 0, expired: 0, paid_late: 0 };
+    for (const o of rows) {
+        const key = statusOf(o.status, o.expiresAt, now);
+        if (Object.hasOwn(counts, key))
+            counts[key]++;
+    }
+    return {
+        counts,
+        totals: { paid: moneyOf(rows.filter((o) => o.status === "paid")), paidLate: moneyOf(rows.filter((o) => o.status === "paid_late")) },
+        orders: shapeOrders(rows, now),
+        players: shapePlayers(owned),
+        rate,
+    };
+}
+/** The `rate` row of the meta table: JSON { usd, sources } kept with the time. Anything that is not that is no rate. */
+export function parseRate(value, at) {
+    if (typeof value !== "string" || typeof at !== "number")
+        return null;
+    try {
+        const v = JSON.parse(value);
+        if (!v || typeof v !== "object")
+            return null;
+        const { usd, sources } = v;
+        if (typeof usd !== "number" || !Number.isFinite(usd) || !Array.isArray(sources) || !sources.every((s) => typeof s === "string"))
+            return null;
+        return { usd, sources: sources, at };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/admin/switches.d.ts

@@ -0,0 +1,58 @@
+/** Which character the player is: Nanoterra's island character (the one the player has there) or the game's own. */
+export type Character = "nanoterra" | "own";
+/** How the game signs a Nanoterra player in: the code exchange, a signed ticket (a game with no server), or not at all. */
+export type Signin = "exchange" | "ticket" | "none";
+export type GameSettings = {
+    character: Character;
+    signin: Signin;
+};
+/** What a press can set: sign-in is on ("exchange": a game with a server) or off ("none"). */
+export type GamePatch = {
+    character?: Character;
+    signin?: "exchange" | "none";
+};
+/** The settings as they are now, and which ones /admin has set (the others still have the game's default). */
+export type GameState = GameSettings & {
+    fromAdmin: {
+        character: boolean;
+        signin: boolean;
+    };
+};
+export declare const isCharacter: (v: unknown) => v is Character;
+export declare const isSigninChoice: (v: unknown) => v is "exchange" | "none";
+export declare const isSignin: (v: unknown) => v is Signin;
+/** The sign-in switch is on for any way but "none". */
+export declare const signinOn: (s: Signin) => boolean;
+/** A request body for a press: only the two known words, at least one. Anything else is refused, with the reason in words. */
+export declare function parsePatch(body: unknown): {
+    ok: true;
+    patch: GamePatch;
+} | {
+    ok: false;
+    error: string;
+};
+/** The settings from what the store kept and the game's defaults. A stored value that is not one of the known words is ignored. */
+export declare function mergeSettings(stored: {
+    character?: unknown;
+    signin?: unknown;
+}, defaults: GameSettings): GameState;
+/** One switch of the card: its title, and one plain sentence for each state. */
+export type SwitchId = "character" | "signin";
+export declare const SWITCHES: Record<SwitchId, {
+    title: string;
+    on: string;
+    off: string;
+}>;
+/**
+ * The character comes through the sign-in: only a player who signs in from Nanoterra brings one. So the character switch is shown with its dependency. With sign-in Off the
+ * card says what a player gets: the island's first character, every player, a player who signed in from Nanoterra before included ("Off means Off"). That is the GAME's page
+ * to do (the starter's src/client/ui/player.ts draws no Nanoterra character while sign-in is Off); the card only says it.
+ */
+export declare const CHARACTER_NEEDS_SIGNIN = "This needs \u201CPlayers can sign in with Nanoterra\u201D to be On: only a player who signs in from Nanoterra brings a character.";
+export declare const CHARACTER_SIGNIN_OFF = "Sign-in from Nanoterra is Off, so every player plays as the island's first character, a player who signed in from Nanoterra before included.";
+/** What to tell the creator under the sign-in switch about Nanoterra's review. A game cannot see that review: it says so. */
+export declare const REVIEW_NOTE = "Your choice is saved here at once. The sign-in word is part of your listing file, and Nanoterra's review decides what Nanoterra shows for a game that is listed. This page cannot see that review. Check it on Nanoterra's launch page (step 6).";
+export declare const REVIEW_LINK = "https://nano133.com/build/nanoterra/launch";
+/** The state of a switch from the settings, and the patch that a press sends (the other state). */
+export declare const stateOf: (id: SwitchId, s: GameSettings) => boolean;
+export declare const pressOf: (id: SwitchId, s: GameSettings) => GamePatch;

package/dist/admin/switches.js

@@ -0,0 +1,61 @@
+// The two switches of the "Game" card in /admin, and the words that say what each does. The handler checks a press with `parsePatch`; the panel
+// draws the card from `SWITCHES`. A switch changes ONLY these two settings; never a look, a price or an order.
+export const isCharacter = (v) => v === "nanoterra" || v === "own";
+export const isSigninChoice = (v) => v === "exchange" || v === "none";
+export const isSignin = (v) => v === "exchange" || v === "ticket" || v === "none";
+/** The sign-in switch is on for any way but "none". */
+export const signinOn = (s) => s !== "none";
+/** A request body for a press: only the two known words, at least one. Anything else is refused, with the reason in words. */
+export function parsePatch(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return { ok: false, error: 'Send an object with "character" or "signin".' };
+    const patch = {};
+    for (const [key, value] of Object.entries(body)) {
+        if (key === "character" && isCharacter(value))
+            patch.character = value;
+        else if (key === "signin" && isSigninChoice(value))
+            patch.signin = value;
+        else if (key === "character")
+            return { ok: false, error: '"character" must be "nanoterra" or "own".' };
+        else if (key === "signin")
+            return { ok: false, error: '"signin" must be "exchange" or "none".' };
+        else
+            return { ok: false, error: `"${key}" is not a game switch.` };
+    }
+    if (!Object.keys(patch).length)
+        return { ok: false, error: 'Send "character" or "signin".' };
+    return { ok: true, patch };
+}
+/** The settings from what the store kept and the game's defaults. A stored value that is not one of the known words is ignored. */
+export function mergeSettings(stored, defaults) {
+    return {
+        character: isCharacter(stored.character) ? stored.character : defaults.character,
+        signin: isSigninChoice(stored.signin) ? stored.signin : defaults.signin,
+        fromAdmin: { character: isCharacter(stored.character), signin: isSigninChoice(stored.signin) },
+    };
+}
+export const SWITCHES = {
+    character: {
+        title: "Players use their Nanoterra character",
+        on: "On: a player who signs in from Nanoterra plays as the character they picked there. Anyone else plays as the island's first character.",
+        off: "Off: every player plays as this game's own character.",
+    },
+    signin: {
+        title: "Players can sign in with Nanoterra",
+        on: "On: this game's listing file says players can sign in with Nanoterra, and the game accepts that sign-in.",
+        off: "Off: the listing file says no sign-in, and the game refuses it: a link made before still signs nobody in.",
+    },
+};
+/**
+ * The character comes through the sign-in: only a player who signs in from Nanoterra brings one. So the character switch is shown with its dependency. With sign-in Off the
+ * card says what a player gets: the island's first character, every player, a player who signed in from Nanoterra before included ("Off means Off"). That is the GAME's page
+ * to do (the starter's src/client/ui/player.ts draws no Nanoterra character while sign-in is Off); the card only says it.
+ */
+export const CHARACTER_NEEDS_SIGNIN = "This needs “Players can sign in with Nanoterra” to be On: only a player who signs in from Nanoterra brings a character.";
+export const CHARACTER_SIGNIN_OFF = "Sign-in from Nanoterra is Off, so every player plays as the island's first character, a player who signed in from Nanoterra before included.";
+/** What to tell the creator under the sign-in switch about Nanoterra's review. A game cannot see that review: it says so. */
+export const REVIEW_NOTE = "Your choice is saved here at once. The sign-in word is part of your listing file, and Nanoterra's review decides what Nanoterra shows for a game that is listed. This page cannot see that review. Check it on Nanoterra's launch page (step 6).";
+export const REVIEW_LINK = "https://nano133.com/build/nanoterra/launch";
+/** The state of a switch from the settings, and the patch that a press sends (the other state). */
+export const stateOf = (id, s) => (id === "character" ? s.character === "nanoterra" : signinOn(s.signin));
+export const pressOf = (id, s) => (id === "character" ? { character: s.character === "nanoterra" ? "own" : "nanoterra" } : { signin: signinOn(s.signin) ? "none" : "exchange" });

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;