@nano133/nanoterra 0.4.0 → 0.6.0

package/dist/friends/panel/window.d.ts

@@ -0,0 +1,52 @@
+/** The `source` of every message, both ways. A message with another `source` is not for this contract. */
+export declare const WINDOW_SOURCE = "nanoterra-friends";
+/** The version of the messages. A message with another `v` is ignored. */
+export declare const WINDOW_V = 1;
+type Head = {
+    source: "nanoterra-friends";
+    v: 1;
+};
+/** Messages from the game's page to the window (sent with the window's origin as the target). */
+export type ToWindow = Head & ({
+    type: "open";
+} | {
+    type: "closed";
+} | {
+    type: "where";
+    where: string | null;
+});
+/** Messages from the window that the kit acts on. Anything else is ignored. */
+export type FromWindow = Head & ({
+    type: "ready";
+} | {
+    type: "size";
+    height: number;
+} | {
+    type: "badge";
+    online: number;
+    requests: number;
+} | {
+    type: "join";
+    url: string;
+} | {
+    type: "signin";
+});
+/** The window's address for a game. */
+export declare function windowUrl(origin: string, game: string): string;
+/** A message to the window. */
+export declare function toWindow(m: {
+    type: "open";
+} | {
+    type: "closed";
+} | {
+    type: "where";
+    where: string | null;
+}): ToWindow;
+/**
+ * The game's `where` as the kit sends it: plain text, control characters removed, trimmed, at most 64 characters (the site does the same again and
+ * shows it as text only). Null when nothing is left.
+ */
+export declare function whereText(where: unknown): string | null;
+/** A message from the window, checked: its source, its version, its type and each field. Null for anything else (a bad field too). */
+export declare function readWindowMessage(data: unknown): FromWindow | null;
+export {};

package/dist/friends/panel/window.js

@@ -0,0 +1,72 @@
+// The nano133 friends window: the contract between the kit and nano133's page /embed/friends (contract v1, accepted by the site on 2026-10-30).
+// The window holds the player's Nanoterra friends and their live connection; the game gets none of them. It says only its height, two counts for
+// the badge, that it needs a tap (Storage Access), and a friend's https address to join (the kit asks the player first). No message carries an
+// address, a pass or a player id.
+/** The `source` of every message, both ways. A message with another `source` is not for this contract. */
+export const WINDOW_SOURCE = "nanoterra-friends";
+/** The version of the messages. A message with another `v` is ignored. */
+export const WINDOW_V = 1;
+/** The window's address for a game. */
+export function windowUrl(origin, game) {
+    return `${origin}/embed/friends?game=${encodeURIComponent(game)}&v=${WINDOW_V}`;
+}
+/** A message to the window. */
+export function toWindow(m) {
+    return { source: WINDOW_SOURCE, v: WINDOW_V, ...m };
+}
+/**
+ * The game's `where` as the kit sends it: plain text, control characters removed, trimmed, at most 64 characters (the site does the same again and
+ * shows it as text only). Null when nothing is left.
+ */
+export function whereText(where) {
+    if (typeof where !== "string")
+        return null;
+    // eslint-disable-next-line no-control-regex
+    const plain = where.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, "").trim();
+    const cut = Array.from(plain).slice(0, 64).join("").trim();
+    return cut || null;
+}
+const count = (v) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.min(99, Math.floor(v)) : null);
+/** A message from the window, checked: its source, its version, its type and each field. Null for anything else (a bad field too). */
+export function readWindowMessage(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return null;
+    const m = data;
+    if (m.source !== WINDOW_SOURCE || m.v !== WINDOW_V || typeof m.type !== "string")
+        return null;
+    const head = { source: WINDOW_SOURCE, v: WINDOW_V };
+    switch (m.type) {
+        case "ready":
+        case "signin":
+            return { ...head, type: m.type };
+        case "size": {
+            if (typeof m.height !== "number" || !Number.isFinite(m.height) || m.height < 0)
+                return null;
+            return { ...head, type: "size", height: Math.min(10_000, Math.ceil(m.height)) };
+        }
+        case "badge": {
+            const online = count(m.online);
+            const requests = count(m.requests);
+            if (online === null || requests === null)
+                return null;
+            return { ...head, type: "badge", online, requests };
+        }
+        case "join": {
+            if (typeof m.url !== "string" || m.url.length > 2048)
+                return null;
+            let url;
+            try {
+                url = new URL(m.url);
+            }
+            catch {
+                return null;
+            }
+            // https only: an island friend's room on nano133, or a friend's game at its listed address. No name or password in it.
+            if (url.protocol !== "https:" || url.username || url.password)
+                return null;
+            return { ...head, type: "join", url: url.href };
+        }
+        default:
+            return null;
+    }
+}

package/dist/friends/rules.d.ts

@@ -0,0 +1,92 @@
+import { type FriendRow, type FriendState } from "./types.js";
+/** An edge as an adapter keeps it. `a` and `b` are the two players' ids, `a < b`. `rev` grows with each write (an adapter may use it to refuse a write on a row that changed). */
+export type EdgeRec = {
+    edge: string;
+    a: string;
+    b: string;
+    from: string;
+    state: "pending" | "friend" | "blocked";
+    blockedBy: string[];
+    at: number;
+    invite: {
+        from: string;
+        where: string;
+        at: number;
+    } | null;
+    rev: number;
+};
+/** What an adapter does after a rule: write this edge (new or changed), delete it, or nothing. */
+export type Plan = {
+    put: EdgeRec;
+} | {
+    drop: EdgeRec;
+} | {
+    none: true;
+};
+/** A presence row: where a player is, which tab said so, and when. */
+export type PresenceRec = {
+    player: string;
+    where: string;
+    lease: string;
+    at: number;
+};
+/** The two ids of a pair in the order an adapter keeps them. */
+export declare const pairOf: (x: string, y: string) => [string, string];
+export declare const otherOf: (rec: EdgeRec, me: string) => string;
+export declare const hasPlayer: (rec: EdgeRec, me: string) => boolean;
+/** A request that nobody answered in time is gone; anything else is live. */
+export declare const liveEdge: (rec: EdgeRec, now: number) => boolean;
+/** A new opaque edge id: random, never made from a player id. */
+export declare function newEdgeId(): string;
+/** An edge id as the browser may send one: letters, digits, "-" and "_", 8 to 64. Anything else is refused before a store is asked. */
+export declare const EDGE_PATTERN: RegExp;
+/** A tab's lease, as for an edge. */
+export declare const LEASE_PATTERN: RegExp;
+/**
+ * The game's `where` text as a store keeps it: control characters removed, spaces at the ends trimmed, cut to FRIEND_WHERE_MAX characters
+ * (whole characters, not halves of one). Null when nothing is left, or when it is not text.
+ */
+export declare function cleanWhere(where: unknown): string | null;
+/** The state of an edge for one of its players, or null when they must not see it (a block by the other, an old request). */
+export declare function stateFor(rec: EdgeRec, me: string, now: number): FriendState | null;
+/**
+ * A request from `me` to `other`. `rec` is the pair's edge (or null); `counts` are the live edges of each, which the adapter reads only when a new
+ * edge would be made (it passes a function).
+ */
+export declare function planRequest(me: string, other: string, rec: EdgeRec | null, now: number, counts: () => Promise<{
+    mine: number;
+    theirs: number;
+}>): Promise<Plan>;
+export declare function planAccept(me: string, rec: EdgeRec | null, now: number): Plan;
+/** Declines a request to `me`, or takes back a request of `me`'s. */
+export declare function planDecline(me: string, rec: EdgeRec | null, now: number): Plan;
+/** Ends a friendship (or a request, either way). A block is ended by unblock, not by remove. */
+export declare function planRemove(me: string, rec: EdgeRec | null, now: number): Plan;
+export declare function planBlock(me: string, rec: EdgeRec | null, now: number): Plan;
+/** Takes `me`'s block away. With no block left the pair has no edge (they are not friends again: either may ask). */
+export declare function planUnblock(me: string, rec: EdgeRec | null, now: number): Plan;
+export declare function planInvite(me: string, rec: EdgeRec | null, where: unknown, now: number): Plan;
+/** The lease and the place of a pulse, checked. `where` null means the tab is leaving (it clears the row only when the lease is the same). */
+export declare function checkPulse(where: unknown, lease: unknown): {
+    where: string | null;
+    lease: string;
+};
+/** What a pulse does to the presence row `was`: the new row, a deletion, or nothing (an old tab that leaves after a newer one came). */
+export declare function planPulse(player: string, where: string | null, lease: string, was: PresenceRec | null, now: number): {
+    put: PresenceRec;
+} | {
+    drop: true;
+} | {
+    none: true;
+};
+/** A presence row that still counts. */
+export declare const presenceLive: (p: PresenceRec | null | undefined, now: number) => p is PresenceRec;
+/**
+ * The browser's view of `me`'s edges. `presence` and `showOnline` are of the OTHER players (only friends' are read). `names` comes from the game's
+ * directory; a player it does not know reads "A player". No player id goes into a row.
+ */
+export declare function buildRows(me: string, recs: EdgeRec[], now: number, names: Map<string, string>, presence: Map<string, PresenceRec>, showOnline: Map<string, boolean>): FriendRow[];
+/** The other players whose names a view needs: every edge `me` can see. */
+export declare function shownOthers(me: string, recs: EdgeRec[], now: number): string[];
+/** The friends of `me` (their presence is read for the view). */
+export declare function friendsOf(me: string, recs: EdgeRec[], now: number): string[];

package/dist/friends/rules.js

@@ -0,0 +1,180 @@
+// The rules of the friends list, as pure functions: every adapter (memory, D1, Firestore) reads its rows, asks these what to write, and writes it
+// in one step. So the rules live in one place, and the conformance suite (./conformance.ts) proves that an adapter keeps them.
+//
+// One pair of players has at most one edge. An edge is a request ("pending", from one of them), a friendship, or a block (by one or both).
+// - A block hides the pair from the player who is blocked, both ways, and wins over a friendship or a request. The player who blocked sees a
+//   "blocked" row, so that they can unblock it.
+// - A request that nobody answered goes after FRIEND_REQUEST_MS: it is not shown and does not count.
+// - Every live edge counts toward FRIEND_LIMIT for both players.
+import { FRIEND_INVITE_MS, FRIEND_LIMIT, FRIEND_LIVE_MS, FRIEND_REQUEST_MS, FRIEND_WHERE_MAX, FriendsError } from "./types.js";
+/** The two ids of a pair in the order an adapter keeps them. */
+export const pairOf = (x, y) => (x < y ? [x, y] : [y, x]);
+export const otherOf = (rec, me) => (rec.a === me ? rec.b : rec.a);
+export const hasPlayer = (rec, me) => rec.a === me || rec.b === me;
+/** A request that nobody answered in time is gone; anything else is live. */
+export const liveEdge = (rec, now) => rec.state !== "pending" || now - rec.at < FRIEND_REQUEST_MS;
+/** A new opaque edge id: random, never made from a player id. */
+export function newEdgeId() {
+    return globalThis.crypto.randomUUID();
+}
+/** An edge id as the browser may send one: letters, digits, "-" and "_", 8 to 64. Anything else is refused before a store is asked. */
+export const EDGE_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
+/** A tab's lease, as for an edge. */
+export const LEASE_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
+/**
+ * The game's `where` text as a store keeps it: control characters removed, spaces at the ends trimmed, cut to FRIEND_WHERE_MAX characters
+ * (whole characters, not halves of one). Null when nothing is left, or when it is not text.
+ */
+export function cleanWhere(where) {
+    if (typeof where !== "string")
+        return null;
+    // eslint-disable-next-line no-control-regex
+    const plain = where.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, "").trim();
+    const cut = Array.from(plain).slice(0, FRIEND_WHERE_MAX).join("").trim();
+    return cut ? cut : null;
+}
+/** The state of an edge for one of its players, or null when they must not see it (a block by the other, an old request). */
+export function stateFor(rec, me, now) {
+    if (!hasPlayer(rec, me) || !liveEdge(rec, now))
+        return null;
+    if (rec.state === "blocked")
+        return rec.blockedBy.includes(me) ? "blocked" : null;
+    if (rec.state === "friend")
+        return "friend";
+    return rec.from === me ? "outgoing" : "incoming";
+}
+const NOT_HERE = "This player is not on your list any more.";
+/** The edge that `me` named, or a refusal: an edge of other players, or one they must not see, reads as gone (it says nothing about why). */
+function mine(rec, me, now) {
+    if (!rec || stateFor(rec, me, now) === null)
+        throw new FriendsError(404, NOT_HERE);
+    return rec;
+}
+/**
+ * A request from `me` to `other`. `rec` is the pair's edge (or null); `counts` are the live edges of each, which the adapter reads only when a new
+ * edge would be made (it passes a function).
+ */
+export async function planRequest(me, other, rec, now, counts) {
+    if (me === other)
+        throw new FriendsError(400, "You cannot add yourself.");
+    const live = rec && liveEdge(rec, now) ? rec : null;
+    if (live?.state === "blocked")
+        throw new FriendsError(409, "This player is not available.");
+    if (live?.state === "friend")
+        return { none: true };
+    if (live?.state === "pending") {
+        if (live.from === me)
+            return { none: true };
+        // The other player already asked: this is an accept.
+        return { put: { ...live, from: me, state: "friend", at: now, invite: null, rev: live.rev + 1 } };
+    }
+    const c = await counts();
+    if (c.mine >= FRIEND_LIMIT)
+        throw new FriendsError(409, "Your friends list is full. Remove someone first.");
+    if (c.theirs >= FRIEND_LIMIT)
+        throw new FriendsError(409, "That player's friends list is full.");
+    const [a, b] = pairOf(me, other);
+    // An old request of the same pair is replaced (same row), so the pair still has one edge.
+    return { put: { edge: rec?.edge ?? newEdgeId(), a, b, from: me, state: "pending", blockedBy: [], at: now, invite: null, rev: (rec?.rev ?? 0) + 1 } };
+}
+export function planAccept(me, rec, now) {
+    const r = mine(rec, me, now);
+    const s = stateFor(r, me, now);
+    if (s === "friend")
+        return { none: true };
+    if (s !== "incoming")
+        throw new FriendsError(409, s === "outgoing" ? "Wait for the other player to accept." : "This request is no longer open.");
+    return { put: { ...r, from: me, state: "friend", at: now, invite: null, rev: r.rev + 1 } };
+}
+/** Declines a request to `me`, or takes back a request of `me`'s. */
+export function planDecline(me, rec, now) {
+    const r = mine(rec, me, now);
+    const s = stateFor(r, me, now);
+    if (s !== "incoming" && s !== "outgoing")
+        throw new FriendsError(409, "This is not a request.");
+    return { drop: r };
+}
+/** Ends a friendship (or a request, either way). A block is ended by unblock, not by remove. */
+export function planRemove(me, rec, now) {
+    const r = mine(rec, me, now);
+    if (stateFor(r, me, now) === "blocked")
+        throw new FriendsError(409, "Unblock this player first.");
+    return { drop: r };
+}
+export function planBlock(me, rec, now) {
+    const r = mine(rec, me, now);
+    if (r.blockedBy.includes(me))
+        return { none: true };
+    const blockedBy = r.state === "blocked" ? [...r.blockedBy, me] : [me];
+    return { put: { ...r, from: me, state: "blocked", blockedBy, at: now, invite: null, rev: r.rev + 1 } };
+}
+/** Takes `me`'s block away. With no block left the pair has no edge (they are not friends again: either may ask). */
+export function planUnblock(me, rec, now) {
+    const r = mine(rec, me, now);
+    if (!r.blockedBy.includes(me))
+        throw new FriendsError(409, "This player is not blocked.");
+    const left = r.blockedBy.filter((p) => p !== me);
+    if (!left.length)
+        return { drop: r };
+    return { put: { ...r, blockedBy: left, at: now, rev: r.rev + 1 } };
+}
+export function planInvite(me, rec, where, now) {
+    const r = mine(rec, me, now);
+    if (stateFor(r, me, now) !== "friend")
+        throw new FriendsError(409, "You can invite only a friend.");
+    const place = cleanWhere(where);
+    if (!place)
+        throw new FriendsError(400, "Say where to meet.");
+    return { put: { ...r, invite: { from: me, where: place, at: now }, rev: r.rev + 1 } };
+}
+/** The lease and the place of a pulse, checked. `where` null means the tab is leaving (it clears the row only when the lease is the same). */
+export function checkPulse(where, lease) {
+    if (typeof lease !== "string" || !LEASE_PATTERN.test(lease))
+        throw new FriendsError(400, "A pulse needs a lease of 8 to 64 letters or digits.");
+    if (where === null)
+        return { where: null, lease };
+    const place = cleanWhere(where);
+    if (!place)
+        throw new FriendsError(400, "Say where you are, or send null to leave.");
+    return { where: place, lease };
+}
+/** What a pulse does to the presence row `was`: the new row, a deletion, or nothing (an old tab that leaves after a newer one came). */
+export function planPulse(player, where, lease, was, now) {
+    if (where !== null)
+        return { put: { player, where, lease, at: now } };
+    if (was && was.lease === lease)
+        return { drop: true };
+    return { none: true };
+}
+/** A presence row that still counts. */
+export const presenceLive = (p, now) => Boolean(p) && now - p.at < FRIEND_LIVE_MS && now - p.at >= -FRIEND_LIVE_MS;
+/** The order of the list: requests to answer first, then friends who are online, friends, requests sent, blocks; each by name. */
+const RANK = { incoming: 0, friend: 1, outgoing: 3, blocked: 4 };
+/**
+ * The browser's view of `me`'s edges. `presence` and `showOnline` are of the OTHER players (only friends' are read). `names` comes from the game's
+ * directory; a player it does not know reads "A player". No player id goes into a row.
+ */
+export function buildRows(me, recs, now, names, presence, showOnline) {
+    const rows = [];
+    for (const rec of recs) {
+        const state = stateFor(rec, me, now);
+        if (!state)
+            continue;
+        const other = otherOf(rec, me);
+        const p = state === "friend" && showOnline.get(other) !== false ? presence.get(other) : undefined;
+        const online = presenceLive(p, now);
+        const invite = state === "friend" && rec.invite && rec.invite.from !== me && now - rec.invite.at < FRIEND_INVITE_MS && now - rec.invite.at >= -FRIEND_INVITE_MS ? { where: rec.invite.where, at: rec.invite.at } : null;
+        const name = names.get(other);
+        rows.push({ edge: rec.edge, name: typeof name === "string" && name ? name : "A player", state, online, where: online ? p.where : null, invite, rank: state === "friend" && online ? 0.5 : RANK[state] });
+    }
+    rows.sort((x, y) => x.rank - y.rank || x.name.localeCompare(y.name) || (x.edge < y.edge ? -1 : 1));
+    return rows.map(({ rank: _rank, ...row }) => row);
+}
+/** The other players whose names a view needs: every edge `me` can see. */
+export function shownOthers(me, recs, now) {
+    return [...new Set(recs.filter((r) => stateFor(r, me, now) !== null).map((r) => otherOf(r, me)))];
+}
+/** The friends of `me` (their presence is read for the view). */
+export function friendsOf(me, recs, now) {
+    return recs.filter((r) => stateFor(r, me, now) === "friend").map((r) => otherOf(r, me));
+}

package/dist/friends/types.d.ts

@@ -0,0 +1,58 @@
+/** A row of a player's list, as the browser gets it. `edge` is the store's opaque id for the pair (never a player id). */
+export type FriendState = "friend" | "incoming" | "outgoing" | "blocked";
+export type FriendRow = {
+    edge: string;
+    name: string;
+    state: FriendState;
+    online: boolean;
+    where: string | null;
+    invite: {
+        where: string;
+        at: number;
+    } | null;
+};
+export type FriendView = {
+    showOnline: boolean;
+    people: FriendRow[];
+};
+/** Live rows a player may have (friends, requests both ways, blocks), as the island. */
+export declare const FRIEND_LIMIT = 100;
+/** A pulse counts as online this long. */
+export declare const FRIEND_LIVE_MS = 120000;
+/** An invite shows this long. */
+export declare const FRIEND_INVITE_MS = 600000;
+/** An unanswered request goes after this. */
+export declare const FRIEND_REQUEST_MS: number;
+/** The longest `where` a store keeps (after trimming and removing control characters). */
+export declare const FRIEND_WHERE_MAX = 64;
+/** The game's players, which only the game knows: its sign-in id for a name, and the names to show. */
+export interface PlayerDirectory {
+    byName(name: string): Promise<string | null>;
+    names(ids: string[]): Promise<Map<string, string>>;
+}
+/** The game's database for friends. An adapter writes ONLY friend rows, presence rows and the show-online choice. */
+export interface FriendsStore {
+    view(player: string, directory: PlayerDirectory, now: number): Promise<FriendView>;
+    /** A request by the other player's id; an accept when the other already asked. Refuses: self, a full list, a block. */
+    request(player: string, other: string, now: number): Promise<void>;
+    accept(player: string, edge: string, now: number): Promise<void>;
+    decline(player: string, edge: string): Promise<void>;
+    remove(player: string, edge: string): Promise<void>;
+    block(player: string, edge: string, now: number): Promise<void>;
+    unblock(player: string, edge: string, now: number): Promise<void>;
+    /** Only between friends; `where` is the game's own text (a room, a level), at most 64 characters. */
+    invite(player: string, edge: string, where: string, now: number): Promise<void>;
+    /** Presence: here now (`where` or null), kept FRIEND_LIVE_MS; a `lease` per tab, so an old tab cannot clear a new one. */
+    pulse(player: string, where: string | null, lease: string, now: number): Promise<void>;
+    setShowOnline(player: string, on: boolean): Promise<void>;
+    /** A player's "delete my data": every row of theirs; returns how many. */
+    forget(player: string): Promise<number>;
+}
+/**
+ * A refusal of a store or the handler: the status to answer and words a player can read. A store throws it for a rule (a block, a full list, an edge
+ * that is not theirs); anything else it throws is a fault, and the handler answers a plain 500.
+ */
+export declare class FriendsError extends Error {
+    status: 400 | 401 | 403 | 404 | 409 | 413 | 429;
+    constructor(status: 400 | 401 | 403 | 404 | 409 | 413 | 429, message: string);
+}

package/dist/friends/types.js

@@ -0,0 +1,24 @@
+// The friends list of a game's OWN players: the types, the limits and the store contract. The package never sees a Nanoterra account here: a
+// player is the game's own id, and a name comes from the game's own directory. (Nanoterra's friends are another thing: the nano133 window, ./panel.)
+/** Live rows a player may have (friends, requests both ways, blocks), as the island. */
+export const FRIEND_LIMIT = 100;
+/** A pulse counts as online this long. */
+export const FRIEND_LIVE_MS = 120_000;
+/** An invite shows this long. */
+export const FRIEND_INVITE_MS = 600_000;
+/** An unanswered request goes after this. */
+export const FRIEND_REQUEST_MS = 30 * 86_400_000;
+/** The longest `where` a store keeps (after trimming and removing control characters). */
+export const FRIEND_WHERE_MAX = 64;
+/**
+ * A refusal of a store or the handler: the status to answer and words a player can read. A store throws it for a rule (a block, a full list, an edge
+ * that is not theirs); anything else it throws is a fault, and the handler answers a plain 500.
+ */
+export class FriendsError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "FriendsError";
+    }
+}

package/dist/looks/change.d.ts

@@ -3,16 +3,16 @@ import { type Look, type Problem, type Slots } from "./look.js";
 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, 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.
+ * list, its wear slot changed (a shovel that a player owns must stay a shovel), 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" | "slots";
+export type LookField = "name" | "priceUsd" | "wear" | "body" | "hat" | "hatColor" | "slots";
 export type LooksDiff = {
     added: Look[];
     removed: Look[];
-    /** Looks with the same id and a different name, price, colour, hat or slots. */
+    /** Looks with the same id and a different name, price, wear slot, colour, hat or slots. */
     changed: {
         id: string;
         before: Look;

package/dist/looks/change.js

@@ -1,4 +1,4 @@
-import { COLOR_PATTERN, cleanSlots } from "./look.js";
+import { COLOR_PATTERN, cleanSlots, wearOf } 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) ?? {};
@@ -12,9 +12,9 @@ export function sameSlots(a, b) {
 // 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, 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.
+ * list, its wear slot changed (a shovel that a player owns must stay a shovel), 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));
@@ -28,6 +28,9 @@ export function removalProblems(before, after, owned) {
         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 (wearOf(l) !== wearOf(kept.look)) {
+            out.push({ look: kept.place, field: "wear", message: `The look "${l.id}" (${l.name}) is worn in the "${wearOf(l)}" slot, and a player owns it. Keep it in that slot, or add a new look for the "${wearOf(kept.look)}" slot.` });
+        }
         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.` });
         }
@@ -48,11 +51,13 @@ export function diffLooks(before, after) {
             fields.push("name");
         if (a.priceUsd !== b.priceUsd)
             fields.push("priceUsd");
-        if (a.change.body.toLowerCase() !== b.change.body.toLowerCase())
+        if (wearOf(a) !== wearOf(b))
+            fields.push("wear");
+        if ((a.change?.body ?? "").toLowerCase() !== (b.change?.body ?? "").toLowerCase())
             fields.push("body");
-        if (a.change.hat !== b.change.hat)
+        if (a.change?.hat !== b.change?.hat)
             fields.push("hat");
-        if ((a.change.hatColor ?? "").toLowerCase() !== (b.change.hatColor ?? "").toLowerCase())
+        if ((a.change?.hatColor ?? "").toLowerCase() !== (b.change?.hatColor ?? "").toLowerCase())
             fields.push("hatColor");
         if (!sameSlots(a.slots, b.slots))
             fields.push("slots");

package/dist/looks/index.d.ts

@@ -1,5 +1,5 @@
-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 { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, OUTFIT, PRICE_MAX_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, lookProblems, checkLooks, cleanSlots, slotValueOk, usdText, wearOf, isOutfit } from "./look.js";
+export type { Change, 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, sameSlots } from "./change.js";

package/dist/looks/index.js

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

package/dist/looks/json.d.ts

@@ -1,7 +1,8 @@
 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 (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.
+ * The text of looks.json for a list of looks: one look on each line, in the order id, name, priceUsd, wear (an item of a wear slot other than the outfit's),
+ * change (an outfit) 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. An
+ * outfit 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,18 +1,25 @@
-import { cleanSlots, ID_PATTERN } from "./look.js";
+import { cleanSlots, ID_PATTERN, isOutfit, OUTFIT, wearOf } 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 (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.
+ * The text of looks.json for a list of looks: one look on each line, in the order id, name, priceUsd, wear (an item of a wear slot other than the outfit's),
+ * change (an outfit) 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. An
+ * outfit with no slots is written exactly as before. It ends with a new line.
  */
 export function looksJson(looks) {
     const row = (l) => {
-        const change = [`"body": ${JSON.stringify(l.change.body)}`];
-        if (l.change.hat !== undefined)
-            change.push(`"hat": ${JSON.stringify(l.change.hat)}`);
-        if (l.change.hatColor !== undefined)
-            change.push(`"hatColor": ${JSON.stringify(l.change.hatColor)}`);
+        let middle;
+        if (isOutfit(l)) {
+            const change = [`"body": ${JSON.stringify(l.change.body)}`];
+            if (l.change.hat !== undefined)
+                change.push(`"hat": ${JSON.stringify(l.change.hat)}`);
+            if (l.change.hatColor !== undefined)
+                change.push(`"hatColor": ${JSON.stringify(l.change.hatColor)}`);
+            middle = `, "change": { ${change.join(", ")} }`;
+        }
+        else
+            middle = wearOf(l) === OUTFIT ? "" : `, "wear": ${JSON.stringify(wearOf(l))}`;
         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 `  { "id": ${JSON.stringify(l.id)}, "name": ${JSON.stringify(l.name)}, "priceUsd": ${l.priceUsd}${middle}${tail} }`;
     };
     return `[\n${looks.map(row).join(",\n")}\n]\n`;
 }