@songsid/agend 2.3.2-beta.1 → 2.3.2-beta.11

package/dist/ui/fleet-office-pack.js

@@ -24,21 +24,45 @@
 //     "areas": {                                      named zones: a rect [x, y, w, h] and its seats, in the order
 //       "desks":  { "rect": [40, 120, 620, 440], "seats": [[120, 220], [260, 220], …] },    they fill up
 //       "lounge": { "rect": [700, 120, 540, 260], "seats": [[760, 260], …] } },
+//                                                     a seat is [x, y], or (#2691) { "x": 760, "y": 260, "for":
+//                                                     ["atlas", …], "lend": false }: reserved for those instances
+//                                                     (names checked like byInstance's, ≤ 16, none twice) — whoever
+//                                                     of them comes to the area takes it first, and nobody else does
+//                                                     unless "lend" (default false) lends it while they are all
+//                                                     elsewhere (a borrower moves off when one comes). A checked
+//                                                     seat is { x, y } — plus, reserved, `for` and `lend`
 //     "stateZones": { "working": "desks", "idle": "lounge", "needs": "alert", "default": "lounge" },
 //                                                     the org chart's states (fleet-org.js ORG_STATES) → an area; a
 //                                                     state it does not name goes to "default", else the first area
 //     "door": [640, 700],                             optional: where someone new walks in from (default: bottom middle)
 //     "waypoints": [{ "id": "hall", "x": 640, "y": 600 }, …], "edges": [["hall", "east"], …],
 //                                                     optional: the walkable graph (else people walk straight)
+//     "straight": true,                               optional (#2634): every walk goes across, then up or down — each
+//                                                     diagonal leg an L, so the walkSide / walkDown / walkUp strips
+//                                                     always fit (graph edges laid out across and up/down put the
+//                                                     corners on the aisles); default false
 //     "furniture": [ { "id": "rack", "sprite": STRIP, "x": 1020, "y": 140, "depth": 2,
-//                      "activeWhen": "crashed", "activeSprite": STRIP } ],
+//                      "activeWhen": "crashed", "activeSprite": STRIP, "activeFor": "atlas", "loop": true, "label": "Rack",
+//                      "night": { "sprite": STRIP, "x": 300, "y": 420 },
+//                      "walk": { "walk": STRIP, "walkDown": STRIP, "walkUp": STRIP, "walkSide": STRIP } } ],
+//                                                     "label" (#2574): a name tag under it, like a person's
+//                                                     (an NPC drawn as furniture). "night" (#2568), optional: at bedtime
+//                                                     (when the viewer has it on: 00:00–06:00 their time) drawn as this
+//                                                     strip, playing, at (x, y) — its own place for either left out.
+//                                                     "walk" (#2596), optional: it strolls near its (x, y) and back
+//                                                     like an idle person, drawn walking by these strips as a
+//                                                     character set's walking poses ("walk" required); not at bedtime
+//                                                     with a "night".
 //                                                     drawn by depth: below 1000 under the people, 1000 and up over
 //                                                     them; "depth": "y" (the string) sorts it among the people by base
 //                                                     y — its anchor's y against each person's feet: someone whose feet
 //                                                     are lower down (a greater y; a tie too) is drawn after it, in
 //                                                     front. (x, y) is where the strip's anchor goes. `activeWhen` (a
 //                                                     state, or a list): while anyone shown is in it, the item plays its
-//                                                     strip (or `activeSprite`); otherwise it holds the first frame
+//                                                     strip (or `activeSprite`); otherwise it holds the first frame —
+//                                                     or, with "loop": true (#2570), plays its strip all along.
+//                                                     "activeFor" (an instance's name, or a list): only their state
+//                                                     counts, not anyone's (a room several people take turns in)
 //     "characters": { "default": { "working": STRIP, "idle": STRIP, "paused": STRIP, "needs": STRIP, "walk": STRIP,
 //                                  "walkDown": STRIP, "walkUp": STRIP, "walkSide": STRIP },
 //                     "fox": { … } },                 "default" with at least "idle" is required; a missing pose is idle.
@@ -47,6 +71,9 @@
 //                                                     walkSide, drawn as it is when moving right and mirrored when moving
 //                                                     left (so draw it facing right). A missing one is "walk", then idle
 //                                                     ("walk" itself is never mirrored)
+//                                                     A set may also have "prop": STRIP (#2562) — what its people
+//                                                     send: their messages, work and reports fly as it, in place of
+//                                                     the pack's "props" (a set without one: the pack's props)
 //     "byInstance": { "atlas": "fox" },               optional: an instance name → its character set
 //     "props": { "task": STRIP, "send": STRIP, "report": STRIP, "broadcast": STRIP },   optional traffic items
 //     "bubbles": { "en": { "working": ["On it."] }, "zh-TW": { … } }   optional: short lines per state (≤ 12 a state,
@@ -82,6 +109,10 @@
 //   { "pack": "cozy",                                 the pack they were made on (on another pack they are ignored)
 //     "seats": { "desks": [[120, 220], …] },          an area's seats: as many as the pack's, each inside the area's rect
 //     "furniture": { "rack": [1000, 150] },           an item's (x, y)
+//     "furnitureNight": { "elder": [300, 420] },      an item's night place (#2665: an item with a "night" only)
+//     "seatFor": { "desks": { "0": { "for": ["atlas"], "lend": false } } },
+//                                                     a seat's reservation by area and slot (#2691), in place of the
+//                                                     pack's own for that seat; "for": [] is none (lends nothing)
 //     "door": [640, 700],
 //     "waypoints": [{ "id": "hall", "x": 640, "y": 600 }, …], "edges": [["hall", "east"], …] }
 //                                                     the walkable graph, replaced whole (edges need waypoints)
@@ -89,18 +120,30 @@
 // Every coordinate is on the same 1280×720 logical canvas, in the same ranges as the pack's. checkLayoutOverrides is
 // the shape (the host checks it on every PUT /ui/offices); applyOverrides puts them on a checked pack, refusing a
 // seat outside its area, an area or furniture the pack does not have, or a seat count that differs (the host checks
-// that too, for a pack it keeps).
+// that too, for a pack it keeps). A night place goes on the item's `night` (its x, y), so at bedtime (nightFurniture)
+// it is the office's, else the pack's night x/y, else the item's (moved) day place. The host keeps `furnitureNight`
+// and `seatFor` (#2691) beside the offices on disk, never inside them: an older host's stricter check would drop the
+// office (#2665, web-office-store.ts).
 
 export const LOGICAL = { w: 1280, h: 720 };
 /** The people's depth: furniture below it is drawn under them, the rest over them. */
 export const CHAR_DEPTH = 1000;
 export const PACK_STATES = ["needs", "crashed", "stuck", "working", "idle", "paused", "stopped", "missing"];
 const POSES = ["working", "idle", "paused", "needs", "walk", "walkDown", "walkUp", "walkSide"], PROPS = ["task", "send", "report", "broadcast"];
+/** A character set's strips: its poses, and what its people send (#2562). */
+const SET_STRIPS = [...POSES, "prop"];
+/** A furniture item's walking strips (#2596): a character set's walking poses. */
+const WALKS = ["walk", "walkDown", "walkUp", "walkSide"];
 const BUILT_IN = new Set(["pixel", "studio"]);
+/**
+ * Ids built in after packs could be uploaded under them (#2631: "cozy"): a new upload is refused, but a pack the host
+ * kept under one before (`kept`) is still read back, listed and deletable, and wins the id for the offices that name it.
+ */
+const RESERVED = new Set(["cozy"]);
 const ID = /^[A-Za-z0-9_-]{1,40}$/;
 const SRC = /^[A-Za-z0-9._/-]{1,200}$/;
 const HEX = /^#[0-9a-f]{6}$/i;
-const LIMIT = { areas: 32, seats: 64, furniture: 128, waypoints: 512, edges: 2048, sets: 64, byInstance: 500, lines: 12, line: 40 };
+const LIMIT = { areas: 32, seats: 64, furniture: 128, waypoints: 512, edges: 2048, sets: 64, byInstance: 500, lines: 12, line: 40, seatFor: 16 };
 
 class Refused extends Error { constructor(at, why) { super(`${at}: ${why}`); } }
 /** `o[k]` when it is o's own property, else undefined: a name from a pack or a page never reaches Object.prototype. */
@@ -138,6 +181,47 @@ export function checkStrip(v, at = "strip", scale = 2) {
   return { src: src(v.src, `${at}.src`), frames: int(v.frames, 1, 32, `${at}.frames`), w, h, fps: v.fps === undefined ? 4 : num(v.fps, 0, 30, `${at}.fps`),
     ax: v.ax === undefined ? w / 2 : num(v.ax, 0, w, `${at}.ax`), ay: v.ay === undefined ? h : num(v.ay, 0, h, `${at}.ay`), dw, dh };
 }
+/** A furniture item's night (#2568): { sprite, x, y } — at bedtime it is drawn as `sprite` (playing) at (x, y), its own place when left out. */
+function nightOf(v, at, scale) {
+  if (v === undefined) return null;
+  obj(v, at); keys(v, ["sprite", "x", "y"], at);
+  return { sprite: checkStrip(v.sprite, `${at}.sprite`, scale), x: v.x === undefined ? null : num(v.x, 0, LOGICAL.w, `${at}.x`), y: v.y === undefined ? null : num(v.y, 0, LOGICAL.h, `${at}.y`) };
+}
+/** A furniture item's walk (#2596): its walking strips, picked by heading as a character set's (poseStrip); "walk" required. */
+function walkOf(v, at, scale) {
+  if (v === undefined) return null;
+  const w = strips(v, WALKS, at, scale);
+  if (!w.walk) throw new Refused(`${at}.walk`, "required");
+  return w;
+}
+/** Whose state an item's activeWhen watches (#2570): an instance's name, or a list of up to `max` (8). */
+function names(v, at, max = 8) {
+  const one = (s, here) => { if (typeof s !== "string" || !s || s.length > 200 || inherited(s) || /[\u0000-\u001f\u007f]/.test(s)) throw new Refused(here, "an instance's name"); return s; };
+  return Array.isArray(v) ? list(v, max, at).map((s, i) => one(s, `${at}[${i}]`)) : [one(v, at)];
+}
+/** Whom a seat is reserved for (#2691): instances' names (as names()), up to LIMIT.seatFor, none twice; `empty` may be []. */
+function owners(v, at, empty = false) {
+  const out = names(v, at, LIMIT.seatFor);
+  if (!out.length && !empty) throw new Refused(at, "at least one instance");
+  if (new Set(out).size !== out.length) throw new Refused(at, "a name twice");
+  return out;
+}
+/**
+ * A seat (#2691): [x, y], or { x, y, for, lend } — reserved for `for` (lent to anyone while they are all elsewhere when
+ * `lend`). Checked: { x, y }, with `for` and `lend` only when reserved, so a plain seat is what it always was.
+ */
+function seatOf(v, at, rect) {
+  let p = null, extra = {};
+  if (isObj(v)) {
+    keys(v, ["x", "y", "for", "lend"], at);
+    p = { x: num(v.x, 0, LOGICAL.w, `${at}.x`), y: num(v.y, 0, LOGICAL.h, `${at}.y`) };
+    if (v.lend !== undefined && typeof v.lend !== "boolean") throw new Refused(`${at}.lend`, "true or false");
+    if (v.lend !== undefined && v.for === undefined) throw new Refused(`${at}.lend`, "only with for");
+    if (v.for !== undefined) extra = { for: owners(v.for, `${at}.for`), lend: v.lend === true };
+  } else p = point(v, at);
+  if (p.x < rect.x || p.x > rect.x + rect.w || p.y < rect.y || p.y > rect.y + rect.h) throw new Refused(at, "outside its area's rect");
+  return { ...p, ...extra };
+}
 function strips(v, names, at, scale) {
   obj(v, at);
   keys(v, names, at);
@@ -148,16 +232,20 @@ function states(v, at) {
   return Array.isArray(v) ? list(v, 8, at).map((s, i) => one(s, `${at}[${i}]`)) : [one(v, at)];
 }
 
-/** A pack's manifest, strictly: { ok: true, pack } or { ok: false, error: "<where>: <why>" }. */
-export function checkSkinPack(x) {
+/**
+ * A pack's manifest, strictly: { ok: true, pack } or { ok: false, error: "<where>: <why>" }. `kept`: a pack the host
+ * keeps already (read back, not uploaded), which may hold a RESERVED id.
+ */
+export function checkSkinPack(x, { kept = false } = {}) {
   try {
     obj(x, "pack");
-    keys(x, ["format", "id", "scale", "background", "foreground", "matte", "areas", "stateZones", "door", "waypoints", "edges", "furniture", "characters", "byInstance", "props", "bubbles", "room", "desk"], "pack");
+    keys(x, ["format", "id", "scale", "background", "foreground", "matte", "areas", "stateZones", "door", "waypoints", "edges", "straight", "furniture", "characters", "byInstance", "props", "bubbles", "room", "desk"], "pack");
     if (x.format !== 1) throw new Refused("format", "1");
     if (typeof x.id !== "string" || !ID.test(x.id)) throw new Refused("id", "1–40 letters, digits, _ or -");
-    if (BUILT_IN.has(x.id)) throw new Refused("id", "a built-in skin's id");
+    if (BUILT_IN.has(x.id) || (!kept && RESERVED.has(x.id))) throw new Refused("id", "a built-in skin's id");
     const scale = x.scale === undefined ? 2 : int(x.scale, 1, 8, "scale");
     if (x.matte !== undefined && !matteOk(x.matte)) throw new Refused("matte", "a colour as #rrggbb");
+    if (x.straight !== undefined && typeof x.straight !== "boolean") throw new Refused("straight", "true or false");
     const areas = {};
     const rawAreas = x.areas === undefined ? {} : obj(x.areas, "areas");
     if (Object.keys(rawAreas).length > LIMIT.areas) throw new Refused("areas", `at most ${LIMIT.areas}`);
@@ -168,11 +256,7 @@ export function checkSkinPack(x) {
       if (!Array.isArray(a.rect) || a.rect.length !== 4) throw new Refused(`${at}.rect`, "[x, y, w, h]");
       const [rx, ry] = [num(a.rect[0], 0, LOGICAL.w, `${at}.rect[0]`), num(a.rect[1], 0, LOGICAL.h, `${at}.rect[1]`)];
       const rect = { x: rx, y: ry, w: num(a.rect[2], 1, LOGICAL.w - rx, `${at}.rect[2]`), h: num(a.rect[3], 1, LOGICAL.h - ry, `${at}.rect[3]`) };
-      const seats = list(a.seats, LIMIT.seats, `${at}.seats`).map((s, i) => {
-        const p = point(s, `${at}.seats[${i}]`);
-        if (p.x < rect.x || p.x > rect.x + rect.w || p.y < rect.y || p.y > rect.y + rect.h) throw new Refused(`${at}.seats[${i}]`, "outside its area's rect");
-        return p;
-      });
+      const seats = list(a.seats, LIMIT.seats, `${at}.seats`).map((s, i) => seatOf(s, `${at}.seats[${i}]`, rect));
       if (!seats.length) throw new Refused(`${at}.seats`, "at least one seat");
       areas[name] = { name, rect, seats };
     }
@@ -204,20 +288,25 @@ export function checkSkinPack(x) {
     const fids = new Set();
     const furniture = list(x.furniture ?? [], LIMIT.furniture, "furniture").map((f, i) => {
       const at = `furniture[${i}]`;
-      obj(f, at); keys(f, ["id", "sprite", "x", "y", "depth", "activeWhen", "activeSprite"], at);
+      obj(f, at); keys(f, ["id", "sprite", "x", "y", "depth", "activeWhen", "activeSprite", "activeFor", "loop", "label", "night", "walk"], at);
       if (!nameOk(f.id) || fids.has(f.id)) throw new Refused(`${at}.id`, "a new name of letters, digits, _ or - (not an inherited one)");
       fids.add(f.id);
       if (f.activeSprite !== undefined && f.activeWhen === undefined) throw new Refused(`${at}.activeSprite`, "only with activeWhen");
+      if (f.activeFor !== undefined && f.activeWhen === undefined) throw new Refused(`${at}.activeFor`, "only with activeWhen");
+      if (f.loop !== undefined && typeof f.loop !== "boolean") throw new Refused(`${at}.loop`, "true or false");
+      if (f.label !== undefined && (typeof f.label !== "string" || !f.label.trim() || [...f.label].length > LIMIT.line || /[\u0000-\u001f\u007f]/.test(f.label))) throw new Refused(`${at}.label`, `1–${LIMIT.line} characters`);
       return { id: f.id, sprite: checkStrip(f.sprite, `${at}.sprite`, scale), x: num(f.x, 0, LOGICAL.w, `${at}.x`), y: num(f.y, 0, LOGICAL.h, `${at}.y`),
         depth: f.depth === "y" ? "y" : depth(f.depth ?? 0, `${at}.depth`), activeWhen: f.activeWhen === undefined ? null : states(f.activeWhen, `${at}.activeWhen`),
-        activeSprite: f.activeSprite === undefined ? null : checkStrip(f.activeSprite, `${at}.activeSprite`, scale) };
+        activeSprite: f.activeSprite === undefined ? null : checkStrip(f.activeSprite, `${at}.activeSprite`, scale),
+        activeFor: f.activeFor === undefined ? null : names(f.activeFor, `${at}.activeFor`), loop: f.loop === true, label: f.label === undefined ? null : f.label.trim(), night: nightOf(f.night, `${at}.night`, scale),
+        walk: walkOf(f.walk, `${at}.walk`, scale) };
     }).sort((a, b) => order(a) - order(b));
     const sets = obj(x.characters, "characters");
     if (Object.keys(sets).length > LIMIT.sets) throw new Refused("characters", `at most ${LIMIT.sets} sets`);
     const characters = {};
     for (const [k, v] of Object.entries(sets)) {
       if (!nameOk(k)) throw new Refused(`characters.${k}`, "a name of letters, digits, _ or - (not an inherited one)");
-      characters[k] = strips(v, POSES, `characters.${k}`, scale);
+      characters[k] = strips(v, SET_STRIPS, `characters.${k}`, scale);
       if (!characters[k].idle) throw new Refused(`characters.${k}.idle`, "required");
     }
     if (!own(characters, "default")) throw new Refused("characters.default", "required");
@@ -248,7 +337,7 @@ export function checkSkinPack(x) {
     const opt = (v, at) => (v === undefined ? undefined : src(v, at));
     return { ok: true, pack: {
       format: 1, id: x.id, scale, background: opt(x.background, "background"), foreground: opt(x.foreground, "foreground"), matte: x.matte === undefined ? undefined : x.matte.toLowerCase(), areas, stateZones,
-      door: x.door === undefined ? { x: LOGICAL.w / 2, y: LOGICAL.h - 10 } : point(x.door, "door"), waypoints, edges, furniture, characters, byInstance,
+      door: x.door === undefined ? { x: LOGICAL.w / 2, y: LOGICAL.h - 10 } : point(x.door, "door"), waypoints, edges, straight: x.straight === true, furniture, characters, byInstance,
       props: x.props === undefined ? {} : strips(x.props, PROPS, "props", scale), bubbles,
       room: { floor: opt(room.floor, "room.floor"), wall: opt(room.wall, "room.wall") }, desk: { back: opt(desk.back, "desk.back"), front: opt(desk.front, "desk.front"), lit: opt(desk.lit, "desk.lit") },
     } };
@@ -261,13 +350,18 @@ export function checkSkinPack(x) {
 export const skinPackOk = (x) => { const r = checkSkinPack(x); return r.ok ? r.pack : null; };
 /** Every image a pack names (what a loader fetches before spriteSkin draws). */
 export const packImages = (pack) => [...new Set([pack.background, pack.foreground, pack.room.floor, pack.room.wall, pack.desk.back, pack.desk.front, pack.desk.lit,
-  ...pack.furniture.flatMap((f) => [f.sprite.src, f.activeSprite && f.activeSprite.src]),
+  ...pack.furniture.flatMap((f) => [f.sprite.src, f.activeSprite && f.activeSprite.src, f.night && f.night.sprite.src, ...Object.values(f.walk || {}).map((st) => st.src)]),
   ...Object.values(pack.characters).flatMap((s) => Object.values(s).map((st) => st.src)), ...Object.values(pack.props).map((st) => st.src)].filter(Boolean))];
 
 /** Every frame strip a checked pack names, with where (the host checks each image is frames·w × h). */
 export function packStrips(pack) {
   const out = [];
-  for (const f of pack.furniture) { out.push({ at: `furniture.${f.id}.sprite`, strip: f.sprite }); if (f.activeSprite) out.push({ at: `furniture.${f.id}.activeSprite`, strip: f.activeSprite }); }
+  for (const f of pack.furniture) {
+    out.push({ at: `furniture.${f.id}.sprite`, strip: f.sprite });
+    if (f.activeSprite) out.push({ at: `furniture.${f.id}.activeSprite`, strip: f.activeSprite });
+    if (f.night) out.push({ at: `furniture.${f.id}.night.sprite`, strip: f.night.sprite });
+    for (const [k, st] of Object.entries(f.walk || {})) out.push({ at: `furniture.${f.id}.walk.${k}`, strip: st });
+  }
   for (const [k, set] of Object.entries(pack.characters)) for (const [pose, st] of Object.entries(set)) out.push({ at: `characters.${k}.${pose}`, strip: st });
   for (const [k, st] of Object.entries(pack.props)) out.push({ at: `props.${k}`, strip: st });
   return out;
@@ -276,11 +370,17 @@ export function packStrips(pack) {
 // ── Layout overrides ──
 
 const OV_LIMIT = { areas: LIMIT.areas, seats: LIMIT.seats, furniture: LIMIT.furniture, waypoints: LIMIT.waypoints, edges: LIMIT.edges };
+/** A seat's slot in `seatFor` (#2691): its index in the area's order, as a key ("0", "1", …). */
+const SLOT = /^(0|[1-9][0-9]{0,2})$/;
+/** A seat's reservation as an override keeps it: { for, lend }, or null (not reserved). */
+const reservedOf = (s) => (s.for && s.for.length ? { for: [...s.for], lend: s.lend === true } : null);
+/** A seat with reservation `r` ({ for, lend }; for [] or null: none) in place of its own. */
+const reserve = (s, r) => { const { for: _f, lend: _l, ...p } = s; return r && r.for.length ? { ...p, for: [...r.for], lend: r.lend === true } : p; };
 /** An office's layout overrides, strictly (their shape and ranges): { ok: true, overrides } or { ok: false, error }. */
 export function checkLayoutOverrides(x) {
   try {
     obj(x, "overrides");
-    keys(x, ["pack", "seats", "furniture", "door", "waypoints", "edges"], "overrides");
+    keys(x, ["pack", "seats", "furniture", "furnitureNight", "seatFor", "door", "waypoints", "edges"], "overrides");
     if (typeof x.pack !== "string" || !ID.test(x.pack)) throw new Refused("overrides.pack", "1–40 letters, digits, _ or -");
     const out = { pack: x.pack };
     if (x.seats !== undefined) {
@@ -305,6 +405,36 @@ export function checkLayoutOverrides(x) {
         out.furniture[id] = [q.x, q.y];
       }
     }
+    if (x.furnitureNight !== undefined) {
+      obj(x.furnitureNight, "overrides.furnitureNight");
+      if (Object.keys(x.furnitureNight).length > OV_LIMIT.furniture) throw new Refused("overrides.furnitureNight", `at most ${OV_LIMIT.furniture}`);
+      out.furnitureNight = {};
+      for (const [id, p] of Object.entries(x.furnitureNight)) {
+        if (!nameOk(id)) throw new Refused(`overrides.furnitureNight.${id}`, "an item's id");
+        const q = point(p, `overrides.furnitureNight.${id}`);
+        out.furnitureNight[id] = [q.x, q.y];
+      }
+    }
+    if (x.seatFor !== undefined) {
+      obj(x.seatFor, "overrides.seatFor");
+      if (Object.keys(x.seatFor).length > OV_LIMIT.areas) throw new Refused("overrides.seatFor", `at most ${OV_LIMIT.areas} areas`);
+      out.seatFor = {};
+      for (const [area, slots] of Object.entries(x.seatFor)) {
+        const at = `overrides.seatFor.${area}`;
+        if (!nameOk(area)) throw new Refused(at, "an area's name");
+        obj(slots, at);
+        if (Object.keys(slots).length > OV_LIMIT.seats) throw new Refused(at, `at most ${OV_LIMIT.seats} seats`);
+        out.seatFor[area] = {};
+        for (const [slot, r] of Object.entries(slots)) {
+          const here = `${at}.${slot}`;
+          if (!SLOT.test(slot) || Number(slot) >= OV_LIMIT.seats) throw new Refused(here, `a seat's number, 0 to ${OV_LIMIT.seats - 1}`);
+          obj(r, here); keys(r, ["for", "lend"], here);
+          if (!Array.isArray(r.for)) throw new Refused(`${here}.for`, "a list");
+          if (r.lend !== undefined && typeof r.lend !== "boolean") throw new Refused(`${here}.lend`, "true or false");
+          out.seatFor[area][slot] = { for: owners(r.for, `${here}.for`, true), lend: r.lend === true };
+        }
+      }
+    }
     if (x.door !== undefined) { const q = point(x.door, "overrides.door"); out.door = [q.x, q.y]; }
     if (x.edges !== undefined && x.waypoints === undefined) throw new Refused("overrides.edges", "only with waypoints");
     if (x.waypoints !== undefined) {
@@ -347,12 +477,24 @@ export function applyOverrides(pack, ov) {
       const r = a.rect;
       areas[name] = { ...a, seats: pts.map(([x, y], i) => {
         if (x < r.x || x > r.x + r.w || y < r.y || y > r.y + r.h) throw new Refused(`${at}[${i}]`, "outside its area's rect");
-        return { x, y };
+        return { ...a.seats[i], x, y };                                                     // its reservation kept (#2691)
       }) };
     }
+    for (const [name, slots] of Object.entries(ov.seatFor || {})) {
+      const a = own(areas, name), at = `overrides.seatFor.${name}`;
+      if (!a) throw new Refused(at, "an area the pack defines");
+      for (const slot of Object.keys(slots)) if (!a.seats[Number(slot)]) throw new Refused(`${at}.${slot}`, `a seat the area has (it has ${a.seats.length})`);
+      areas[name] = { ...a, seats: a.seats.map((s, i) => { const v = own(slots, String(i)); return v ? reserve(s, v) : s; }) };
+    }
     const fids = new Set(pack.furniture.map((f) => f.id));
     for (const id of Object.keys(ov.furniture || {})) if (!fids.has(id)) throw new Refused(`overrides.furniture.${id}`, "an item the pack has");
-    const furniture = pack.furniture.map((f) => { const q = own(ov.furniture, f.id); return q ? { ...f, x: q[0], y: q[1] } : f; });
+    const nids = new Set(pack.furniture.filter((f) => f.night).map((f) => f.id));
+    for (const id of Object.keys(ov.furnitureNight || {})) if (!nids.has(id)) throw new Refused(`overrides.furnitureNight.${id}`, "an item with a night the pack has");
+    const furniture = pack.furniture.map((f) => {
+      const q = own(ov.furniture, f.id), n = own(ov.furnitureNight, f.id);
+      if (!q && !n) return f;
+      return { ...f, ...(q ? { x: q[0], y: q[1] } : {}), ...(n ? { night: { ...f.night, x: n[0], y: n[1] } } : {}) };
+    });
     const door = ov.door ? { x: ov.door[0], y: ov.door[1] } : pack.door;
     const graph = ov.waypoints ? { waypoints: ov.waypoints.map((w) => ({ ...w })), edges: (ov.edges || []).map((e) => [e[0], e[1]]) } : { waypoints: pack.waypoints, edges: pack.edges };
     return { ok: true, pack: { ...pack, areas, furniture, door, ...graph } };
@@ -362,6 +504,40 @@ export function applyOverrides(pack, ov) {
   }
 }
 
+/**
+ * #2665: overrides with only the night places `pack` can take (an item it has, with a `night`): a pack changed since
+ * (an item dropped, or its night) drops that entry, never the rest of the layout. applyOverrides itself stays strict
+ * (a write naming an item the pack lacks is refused, as for `furniture`).
+ */
+export function fitNight(pack, ov) {
+  if (!ov || !ov.furnitureNight || ov.pack !== pack.id) return ov;
+  const ok = new Set(pack.furniture.filter((f) => f.night).map((f) => f.id));
+  const kept = Object.entries(ov.furnitureNight).filter(([id]) => ok.has(id));
+  if (kept.length === Object.keys(ov.furnitureNight).length) return ov;
+  const { furnitureNight: _gone, ...rest } = ov;
+  return kept.length ? { ...rest, furnitureNight: Object.fromEntries(kept) } : rest;
+}
+
+/**
+ * #2691: overrides with only the reservations `pack` can take (an area it has, a seat that area has): a pack changed
+ * since drops that entry, never the rest of the layout (as fitNight; applyOverrides stays strict).
+ */
+export function fitSeatFor(pack, ov) {
+  if (!ov || !ov.seatFor || ov.pack !== pack.id) return ov;
+  let dropped = false;
+  const kept = {};
+  for (const [area, slots] of Object.entries(ov.seatFor)) {
+    const a = own(pack.areas, area);
+    const ok = Object.entries(slots).filter(([slot]) => a && !!a.seats[Number(slot)]);
+    // An area the pack no longer has is dropped even with no slots under it (`{}`: 0 kept of 0, yet applyOverrides refuses it).
+    if (!a || ok.length !== Object.keys(slots).length) dropped = true;
+    if (ok.length) kept[area] = Object.fromEntries(ok);
+  }
+  if (!dropped) return ov;
+  const { seatFor: _gone, ...rest } = ov;
+  return Object.keys(kept).length ? { ...rest, seatFor: kept } : rest;
+}
+
 /**
  * What an edited layout keeps as overrides: only the parts that differ from the pack's own (`edited` is a pack with
  * the same areas and furniture, positions moved); null when nothing does (the office goes back to the pack's).
@@ -370,11 +546,22 @@ export function overridesBetween(pack, edited) {
   const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const ov = { pack: pack.id };
   for (const [name, a] of Object.entries(pack.areas)) {
-    const e = own(edited.areas, name);
-    if (e && !same(a.seats, e.seats)) (ov.seats ||= {})[name] = e.seats.map((s) => [s.x, s.y]);
+    const e = own(edited.areas, name), xy = (s) => [s.x, s.y];
+    if (e && !same(a.seats.map(xy), e.seats.map(xy))) (ov.seats ||= {})[name] = e.seats.map(xy);
+    // #2691: a seat whose reservation differs from the pack's (none where the pack has one: for []).
+    if (e) e.seats.forEach((s, i) => {
+      const was = a.seats[i] ? reservedOf(a.seats[i]) : null, now = reservedOf(s);
+      if (a.seats[i] && !same(was, now)) ((ov.seatFor ||= {})[name] ||= {})[String(i)] = now || { for: [], lend: false };
+    });
   }
   const at = new Map(pack.furniture.map((f) => [f.id, f]));
   for (const f of edited.furniture) { const o = at.get(f.id); if (o && (o.x !== f.x || o.y !== f.y)) (ov.furniture ||= {})[f.id] = [f.x, f.y]; }
+  // #2665: a night place that differs from the pack's (its own x/y, or in place: null); in place again is no entry.
+  for (const f of edited.furniture) {
+    const o = at.get(f.id);
+    if (!o || !o.night || !f.night || f.night.x === null || f.night.y === null) continue;
+    if (o.night.x !== f.night.x || o.night.y !== f.night.y) (ov.furnitureNight ||= {})[f.id] = [f.night.x, f.night.y];
+  }
   if (pack.door.x !== edited.door.x || pack.door.y !== edited.door.y) ov.door = [edited.door.x, edited.door.y];
   if (!same(pack.waypoints, edited.waypoints) || !same(pack.edges, edited.edges)) {
     ov.waypoints = edited.waypoints.map((w) => ({ id: w.id, x: w.x, y: w.y }));
@@ -403,6 +590,9 @@ export function poseStrip(set, pose, heading = null) {
   const st = own(set, pose) || own(set, "idle");
   return st ? { strip: st, mirror: false } : null;
 }
+/** The strip a furniture item shows while it walks (#2596: an NPC with `walk`, `walking` and `heading` set where it is
+ * drawn): its walk strip by heading, as a character's (poseStrip); null when it stands (its own sprite, as before). */
+export const walkStrip = (f) => (f && f.walking && f.walk ? poseStrip(f.walk, "walk", f.heading) : null);
 /** The box (logical units) a strip covers with its anchor at (x, y): its displayed size; mirrored about the anchor. */
 export function stripBox(st, x, y, mirror = false) {
   const kx = st.dw / st.w, ky = st.dh / st.h;

package/dist/ui/fleet-office-skin.js

@@ -1,8 +1,9 @@
 // The Office view's art (fleet-office.js draws with it on a <canvas>). A skin draws a layout that fleet-office-model.js
-// (desks) or fleet-office-zones.js (zones) made. Two skins are built in and draw everything procedurally — little
-// pixel people, desks, lamps — so no art ships: "pixel" (the desks layout: a room per team, a desk per instance) and
-// "studio" (the zones layout: work desks, a lounge, an alert corner and a nap corner; people walk to the area for their
-// state). Every drawing call goes through the OfficeSkin interface below, so a skin pack (pictures from an artist,
+// (desks) or fleet-office-zones.js (zones) made. Three skins are built in. Two draw everything procedurally — little
+// pixel people, desks, lamps: "pixel" (the desks layout: a room per team, a desk per instance) and "studio" (the zones
+// layout: work desks, a lounge, an alert corner and a nap corner; people walk to the area for their state). The third,
+// "cozy" (#2631), is the zones layout on one picture shipped with the page (a warm pixel-art office), the same built-in
+// people in it. Every drawing call goes through the OfficeSkin interface below, so a skin pack (pictures from an artist,
 // format v1 in fleet-office-pack.js) can replace any part; a part a pack does not supply falls back to the built-in
 // drawing. An admin uploads a pack (#2513, the host keeps it: src/web-office-skins.ts); loadPackSkin() reads it back —
 // its manifest checked here again (checkSkinPack), its pictures by their content ids — and spriteSkin() draws it.
@@ -40,8 +41,9 @@
 // pictures and draws the characters, props and bubbles each frame. In zones the background is kept; furniture, people (walking
 // along the pack's waypoints), tags, props and bubbles are drawn each frame, furniture by depth around the people (depth "y":
 // among them by base y), then the foreground, then the crowd counts, tags and bubbles.
+import { t } from "/assets/app-i18n.js";
 import { frameAt, nameHash } from "./fleet-office-model.js";
-import { CHAR_DEPTH, LOGICAL, checkSkinPack, own, packImages, poseStrip, stripBox } from "./fleet-office-pack.js";
+import { CHAR_DEPTH, LOGICAL, checkSkinPack, own, packImages, poseStrip, stripBox, walkStrip } from "./fleet-office-pack.js";
 
 export { nameHash };
 
@@ -222,14 +224,16 @@ function drawDeskFront(ctx, d, look, env) {
     ctx.fillStyle = pal.text2; ctx.font = "600 8px system-ui, sans-serif"; ctx.textAlign = "center"; ctx.textBaseline = "middle";
     ctx.fillText(fitText(ctx, env.labels.closed, 32), d.x + 48, d.y + 63);
   }
-  // The name tag.
-  ctx.fillStyle = pal.surface;
-  ctx.fillRect(d.x + 6, d.y + 78, d.w - 12, 16);
-  ctx.strokeStyle = look.match ? pal.focus : pal.border;
-  ctx.lineWidth = look.match ? 2 : 1;
-  ctx.strokeRect(d.x + 6.5, d.y + 78.5, d.w - 13, 15);
-  ctx.fillStyle = pal.text; ctx.font = "600 11px system-ui, sans-serif"; ctx.textAlign = "center"; ctx.textBaseline = "middle";
-  ctx.fillText(fitText(ctx, look.label, d.w - 18), d.x + d.w / 2, d.y + 86.5);
+  // The name tag (#2554: none when `notag` — a tile too small to read it; the page draws it again on hover).
+  if (!look.notag) {
+    ctx.fillStyle = pal.surface;
+    ctx.fillRect(d.x + 6, d.y + 78, d.w - 12, 16);
+    ctx.strokeStyle = look.match ? pal.focus : pal.border;
+    ctx.lineWidth = look.match ? 2 : 1;
+    ctx.strokeRect(d.x + 6.5, d.y + 78.5, d.w - 13, 15);
+    ctx.fillStyle = pal.text; ctx.font = "600 11px system-ui, sans-serif"; ctx.textAlign = "center"; ctx.textBaseline = "middle";
+    ctx.fillText(fitText(ctx, look.label, d.w - 18), d.x + d.w / 2, d.y + 86.5);
+  }
   ctx.restore();
   if (look.match) { ctx.save(); ctx.strokeStyle = pal.focus; ctx.lineWidth = 2; ctx.strokeRect(d.x + 2, d.y + 2, d.w - 4, d.h - 6); ctx.restore(); }
 }
@@ -374,7 +378,7 @@ const STUDIO_FURNITURE = [
 ].sort((a, b) => a.depth - b.depth);
 /** The studio's pack: the same shape as a checked one (fleet-office-pack.js), furniture by `shape` instead of sprites. */
 export const STUDIO_PACK = {
-  format: 1, id: "studio", scale: 1, areas: STUDIO_AREAS, door: { x: HALL_X, y: 704 }, furniture: STUDIO_FURNITURE, ...studioGraph(STUDIO_AREAS),
+  format: 1, id: "studio", scale: 1, areas: STUDIO_AREAS, door: { x: HALL_X, y: 704 }, furniture: STUDIO_FURNITURE, ...studioGraph(STUDIO_AREAS), straight: false,
   stateZones: { working: "desks", idle: "lounge", needs: "alert", crashed: "alert", stuck: "alert", paused: "nap", stopped: "nap", default: "lounge" },
   characters: {}, byInstance: {}, props: {}, bubbles: {},
 };
@@ -511,8 +515,12 @@ export function spriteSkin(pack, images, base = pixelSkin) {
     },
     drawFurniture(ctx, f, active, ms, env) {
       if (f.shape) { drawFurniture(ctx, f, active, ms, env); return; }
-      // Active: its strip (or activeSprite) plays; otherwise its first frame holds.
+      // An NPC walking (#2596): its walk strip for its heading (walkSide mirrored going left), when its picture is loaded.
+      const ws = walkStrip(f);
+      if (ws && strip(ctx, ws.strip, ms, f.x, f.y, null, ws.mirror)) return;
+      // Active: its activeSprite (or its strip) plays; otherwise its strip loops ("loop", #2570) or its first frame holds.
       if (active) strip(ctx, f.activeSprite || f.sprite, ms, f.x, f.y);
+      else if (f.loop) strip(ctx, f.sprite, ms, f.x, f.y);
       else strip(ctx, f.sprite, 0, f.x, f.y, 0);
     },
     drawCharacter(ctx, d, look, ms, env) {
@@ -528,18 +536,84 @@ export function spriteSkin(pack, images, base = pixelSkin) {
       const ps = shown({ ...look, heading: at.heading }, !!at.walking);
       return ps ? stripBox(ps.strip, at.x, at.y, ps.mirror) : base.charBox(look, at);
     },
-    drawProp(ctx, it, ms, env) { if (!strip(ctx, own(pack.props, it.hue), ms, it.x, it.y)) base.drawProp(ctx, it, ms, env); },
+    // An item in the air: its sender's own (their set's "prop", #2562), else the pack's for its kind, else the built-in one.
+    drawProp(ctx, it, ms, env) {
+      const mine = it.from ? own(setOf({ name: it.from }) || {}, "prop") : null;
+      if (!strip(ctx, mine || own(pack.props, it.hue), ms, it.x, it.y)) base.drawProp(ctx, it, ms, env);
+    },
   };
 }
 
+// ── The built-in cozy (#2631): the zones layout on a warm pixel-art office drawn as one picture, the built-in people ──
+
+/** Its picture, shipped with the page (src/ui/shared/office/cozy.png, auth-api.ts ASSETS: public static, as the font). */
+export const COZY_BACKGROUND = "/assets/office-cozy.png";
+const pts = (...xy) => xy.map(([x, y]) => ({ x, y }));
+// The seats are feet points on the picture: chairs in front of the desks, the sofa, the coffee table and machine, the
+// beanbags (a sleeper's bottom), in front of the whiteboard. The rects put a crowd's first extra spots (fleet-office-zones.js
+// overflowSpots: rows from the rect's top) on the aisles: under the first row of desks, in front of the sofa.
+const COZY_AREAS = {
+  desks: { name: "desks", rect: { x: 130, y: 196, w: 430, h: 220 }, seats: pts([193, 238], [336, 238], [481, 238], [193, 354], [336, 354], [481, 354]) },
+  lounge: { name: "lounge", rect: { x: 700, y: 196, w: 476, h: 184 }, seats: pts([940, 240], [1025, 310], [1120, 305]) },
+  alert: { name: "alert", rect: { x: 900, y: 500, w: 220, h: 110 }, seats: pts([965, 570], [1045, 570]) },
+  nap: { name: "nap", rect: { x: 110, y: 470, w: 400, h: 150 }, seats: pts([180, 562], [300, 562], [422, 565]) },
+};
+/** Its walkable graph, on the picture's aisles, every edge across or up/down; each seat's nearest waypoint is in front of it. */
+const COZY_WAYPOINTS = [
+  ["door", 642, 640], ["hall", 642, 395], ["top", 642, 175],
+  // the desks: the aisle under the first row (y 250), the one under the second (y 395), the column beside them (x 560)
+  ["d-east", 560, 395], ["d-up", 560, 250], ["d1-3", 481, 250], ["d1-2", 336, 250], ["d1-1", 193, 250],
+  ["d2-3", 481, 395], ["d2-2", 336, 395], ["d2-x", 300, 395], ["d2-1", 193, 395],
+  // the beanbags: the aisle above them (y 460)
+  ["n-x", 300, 460], ["n-1", 180, 460], ["n-3", 422, 460],
+  // the lounge: below the coffee table (y 340), up the sofa's west end; the coffee machine's column (x 1140)
+  ["l-hall", 946, 395], ["l-mid", 946, 340], ["l-west", 860, 340], ["l-sofa", 860, 250], ["l-table", 1025, 340],
+  ["e-hall", 1140, 395], ["e-coffee", 1140, 305],
+  // the whiteboard: in front of it (y 570), from the coffee machine's column
+  ["a-east", 1140, 570], ["a-mid", 1005, 570],
+].map(([id, x, y]) => ({ id, x, y }));
+const COZY_EDGES = [
+  ["door", "hall"], ["hall", "top"], ["hall", "d-east"], ["d-east", "d2-3"], ["d2-3", "d2-2"], ["d2-2", "d2-x"], ["d2-x", "d2-1"],
+  ["d-east", "d-up"], ["d-up", "d1-3"], ["d1-3", "d1-2"], ["d1-2", "d1-1"], ["d2-x", "n-x"], ["n-x", "n-1"], ["n-x", "n-3"],
+  ["hall", "l-hall"], ["l-hall", "l-mid"], ["l-mid", "l-west"], ["l-west", "l-sofa"], ["l-mid", "l-table"],
+  ["l-hall", "e-hall"], ["e-hall", "e-coffee"], ["e-hall", "a-east"], ["a-east", "a-mid"],
+];
+/** The cozy's pack: the picture is the room; the one item is the notice board, its tag saying a pack can restyle it. */
+export const COZY_PACK = {
+  format: 1, id: "cozy", scale: 1, background: COZY_BACKGROUND, areas: COZY_AREAS, door: { x: 642, y: 662 },
+  waypoints: COZY_WAYPOINTS, edges: COZY_EDGES, straight: true,
+  furniture: [{ id: "notice", x: 1211, y: 628, depth: 5, get label() { return t("orgo.cozyNotice"); } }],
+  stateZones: { working: "desks", idle: "lounge", needs: "alert", crashed: "alert", stuck: "alert", paused: "nap", stopped: "nap", default: "lounge" },
+  characters: {}, byInstance: {}, props: {}, bubbles: {},
+};
+/** Until its picture is in (loadCozySkin): the studio's floors under the cozy's areas. */
+const cozyBare = spriteSkin(COZY_PACK, new Map(), studioSkin);
+let cozyJob = null;
+
 /** The skins built into this page; an uploaded pack is loaded by loadPackSkin. */
-export const SKINS = new Map([["pixel", pixelSkin], ["studio", studioSkin]]);
-export const BUILT_IN_SKINS = ["pixel", "studio"];
+export const SKINS = new Map([["pixel", pixelSkin], ["studio", studioSkin], ["cozy", cozyBare]]);
+export const BUILT_IN_SKINS = ["pixel", "studio", "cozy"];
+/**
+ * #2631: the cozy's picture, loaded once; the skin drawn from it then takes the cozy's place in SKINS (skinFor). The
+ * skin, or null while it cannot load (the bare one stays; tried again next time).
+ */
+export function loadCozySkin({ image = defaultImage } = {}) {
+  if (SKINS.get("cozy") !== cozyBare) return Promise.resolve(SKINS.get("cozy"));
+  cozyJob ??= image(COZY_BACKGROUND).then((im) => {
+    cozyJob = null;
+    if (!im) return null;
+    const sk = spriteSkin(COZY_PACK, new Map([[COZY_BACKGROUND, im]]), studioSkin);
+    SKINS.set("cozy", sk);
+    return sk;
+  }, () => { cozyJob = null; return null; });
+  return cozyJob;
+}
 /** A skin by id: a built-in one, else a pack loaded here (`packs`: id → skin), else the default (pixel). */
 export const skinFor = (id, packs = null) => SKINS.get(id) || (packs && packs.get(id)) || pixelSkin;
 
 const loaded = new Map();                                 // `${id}@${sha}` → Promise<OfficeSkin | null>
-const MAX_LOADED = 16;
+// Room for every pack the host keeps (web-office-skins.ts SKIN_LIMITS.packs) and a few replaced ones (each a new sha).
+const MAX_LOADED = 24;
 const defaultImage = (url) => new Promise((resolve) => {
   if (typeof Image !== "function") { resolve(null); return; }
   const im = new Image();
@@ -550,9 +624,10 @@ const defaultImage = (url) => new Promise((resolve) => {
 /**
  * An uploaded pack (GET /ui/office-skins/<id>?v=<sha>) as an OfficeSkin: its manifest checked (null when it is not a
  * pack: the page then draws a built-in style and says so), its pictures loaded from their content ids (one that does
- * not load is drawn by the built-in skin). Kept per id and sha, so a pack is fetched once.
+ * not load is drawn by the built-in skin). Kept per id and sha, so a pack is fetched once. `url`: where a picture's path
+ * is read (a share link's page reads its own address, #2636).
  */
-export function loadPackSkin(id, sha, { fetch: get = globalThis.fetch, image = defaultImage } = {}) {
+export function loadPackSkin(id, sha, { fetch: get = globalThis.fetch, image = defaultImage, url = (p) => p } = {}) {
   const key = `${id}@${sha}`;
   if (loaded.has(key)) return loaded.get(key);
   const base = `/ui/office-skins/${encodeURIComponent(id)}`;
@@ -561,14 +636,14 @@ export function loadPackSkin(id, sha, { fetch: get = globalThis.fetch, image = d
       const r = await get(`${base}?v=${encodeURIComponent(sha)}`, { method: "GET", headers: { "Content-Type": "application/json" } });
       if (!r || !r.ok) return null;
       const d = await r.json();
-      const c = checkSkinPack(d && d.manifest);
+      const c = checkSkinPack(d && d.manifest, { kept: true });
       if (!c.ok || c.pack.id !== id) return null;
       const files = d.files && typeof d.files === "object" ? d.files : {};
       const images = new Map();
       await Promise.all(packImages(c.pack).map(async (src) => {
         const fid = own(files, src);
         if (typeof fid !== "string" || !/^[0-9a-f]{32}$/.test(fid)) return;
-        const im = await image(`${base}/img/${fid}.png`);
+        const im = await image(url(`${base}/img/${fid}.png`));
         if (im) images.set(src, im);
       }));
       return spriteSkin(c.pack, images);