@songsid/agend 2.3.2-beta.8 → 2.3.2

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

@@ -24,10 +24,21 @@
 //     "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)
+//     "mailDrop": [640, 420],                         optional (#2736): where a letter from another office lands (more
+//                                                     waiting step GAP px right of it, past any seat); default: the
+//                                                     waypoint nearest the middle off every seat (fleet-office-zones.js
+//                                                     dropPoint)
 //     "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
@@ -35,7 +46,7 @@
 //                                                     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, "activeFor": "atlas", "loop": true, "label": "Rack",
+//                      "activeWhen": "crashed", "activeSprite": STRIP, "activeFor": "atlas", "loop": true, "activeOn": "seated", "hides": 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
@@ -55,7 +66,14 @@
 //                                                     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)
+//                                                     counts, not anyone's (a room several people take turns in).
+//                                                     "activeOn" (#2698): "state" (the default) turns it active as the
+//                                                     state changes; "seated" only once one of them in that state is
+//                                                     at the seat zones gave them, not walking — back as they walk off.
+//                                                     "hides": true (#2698, only with activeFor): while active, the
+//                                                     people it is active for are not drawn (walking, they always
+//                                                     are); their name tags and bubbles are drawn on it, in one row at
+//                                                     its tag point, and hovering or clicking it hits them
 //     "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.
@@ -73,6 +91,13 @@
 //                                                     ≤ 40 characters each), in place of the page's own
 //     "room": { "floor": "floor.png", "wall": "wall.png" }, "desk": { "back": …, "front": …, "lit": … }
 //                                                     optional: for the desks layout (a pack without stateZones)
+//     "levels": {                                     optional (#2661): the Office levels' words
+//       "titles": [{ "from": 1, "name": "Intern" }, …],   the title from each level up (≤ 32, `from` 0–100000
+//                                                     rising, a name 1–24 characters), in place of the page's own
+//       "fixed": { "atlas": { "title": "Founder", "hideLevel": true } } }
+//                                                     a title pinned on an instance (or an NPC: a furniture item's
+//                                                     id) whatever its level (≤ 500); hideLevel: its badge is a mark,
+//                                                     its card has no "Lv n" or XP bar
 //   }
 //
 // A STRIP is { "src": "idle.png", "frames": 4, "w": 32, "h": 48, "fps": 4, "ax": 16, "ay": 44 }: `frames` frames of
@@ -102,14 +127,21 @@
 //   { "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)
-//     "door": [640, 700],
+//     "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], "mailDrop": [640, 420],     (#2736: kept beside the offices on disk, as furnitureNight)
 //     "waypoints": [{ "id": "hall", "x": 640, "y": 600 }, …], "edges": [["hall", "east"], …] }
 //                                                     the walkable graph, replaced whole (edges need waypoints)
 //
 // 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. */
@@ -129,7 +161,7 @@ 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, titles: 32, title: 24, fixed: 500 };
 
 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. */
@@ -180,10 +212,33 @@ function walkOf(v, 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 8. */
-function names(v, at) {
+/** 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, 8, at).map((s, i) => one(s, `${at}[${i}]`)) : [one(v, at)];
+  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);
@@ -195,6 +250,43 @@ function states(v, at) {
   return Array.isArray(v) ? list(v, 8, at).map((s, i) => one(s, `${at}[${i}]`)) : [one(v, at)];
 }
 
+/** #2661: a title's words — 1–LIMIT.title characters on one line. */
+function titleText(v, at) {
+  if (typeof v !== "string" || !v.trim() || [...v.trim()].length > LIMIT.title || /[\u0000-\u001f\u007f]/.test(v)) throw new Refused(at, `1–${LIMIT.title} characters`);
+  return v.trim();
+}
+/** #2661: a pack's `levels` (titles, fixed), checked; null when it has none. */
+function levelsOf(v) {
+  if (v === undefined) return null;
+  obj(v, "levels");
+  keys(v, ["titles", "fixed"], "levels");
+  const out = {};
+  if (v.titles !== undefined) {
+    let last = -1;
+    out.titles = list(v.titles, LIMIT.titles, "levels.titles").map((t, i) => {
+      const at = `levels.titles[${i}]`;
+      obj(t, at); keys(t, ["from", "name"], at);
+      const from = int(t.from, 0, 100000, `${at}.from`);
+      if (from <= last) throw new Refused(`${at}.from`, "higher than the title before it");
+      last = from;
+      return { from, name: titleText(t.name, `${at}.name`) };
+    });
+  }
+  if (v.fixed !== undefined) {
+    obj(v.fixed, "levels.fixed");
+    if (Object.keys(v.fixed).length > LIMIT.fixed) throw new Refused("levels.fixed", `at most ${LIMIT.fixed}`);
+    out.fixed = {};
+    for (const [k, f] of Object.entries(v.fixed)) {
+      const at = `levels.fixed.${k}`;
+      if (inherited(k)) throw new Refused(at, "an instance's name (not an inherited one)");
+      obj(f, at); keys(f, ["title", "hideLevel"], at);
+      if (f.hideLevel !== undefined && typeof f.hideLevel !== "boolean") throw new Refused(`${at}.hideLevel`, "true or false");
+      out.fixed[k] = { title: titleText(f.title, `${at}.title`), hideLevel: f.hideLevel === true };
+    }
+  }
+  return out;
+}
+
 /**
  * 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.
@@ -202,7 +294,7 @@ function states(v, at) {
 export function checkSkinPack(x, { kept = false } = {}) {
   try {
     obj(x, "pack");
-    keys(x, ["format", "id", "scale", "background", "foreground", "matte", "areas", "stateZones", "door", "waypoints", "edges", "straight", "furniture", "characters", "byInstance", "props", "bubbles", "room", "desk"], "pack");
+    keys(x, ["format", "id", "scale", "background", "foreground", "matte", "areas", "stateZones", "door", "mailDrop", "waypoints", "edges", "straight", "furniture", "characters", "byInstance", "props", "bubbles", "room", "desk", "levels"], "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) || (!kept && RESERVED.has(x.id))) throw new Refused("id", "a built-in skin's id");
@@ -219,11 +311,7 @@ export function checkSkinPack(x, { kept = false } = {}) {
       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 };
     }
@@ -255,17 +343,22 @@ export function checkSkinPack(x, { kept = false } = {}) {
     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", "activeFor", "loop", "label", "night", "walk"], at);
+      obj(f, at); keys(f, ["id", "sprite", "x", "y", "depth", "activeWhen", "activeSprite", "activeFor", "loop", "activeOn", "hides", "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.activeOn !== undefined && f.activeOn !== "state" && f.activeOn !== "seated") throw new Refused(`${at}.activeOn`, '"state" or "seated"');
+      if (f.activeOn !== undefined && f.activeWhen === undefined) throw new Refused(`${at}.activeOn`, "only with activeWhen");
+      if (f.hides !== undefined && typeof f.hides !== "boolean") throw new Refused(`${at}.hides`, "true or false");
+      if (f.hides !== undefined && f.activeFor === undefined) throw new Refused(`${at}.hides`, "only with activeFor");
       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),
-        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),
+        activeFor: f.activeFor === undefined ? null : names(f.activeFor, `${at}.activeFor`), loop: f.loop === true,
+        activeOn: f.activeOn === "seated" ? "seated" : "state", hides: f.hides === 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");
@@ -299,14 +392,17 @@ export function checkSkinPack(x, { kept = false } = {}) {
         });
       }
     }
+    const levels = levelsOf(x.levels);
     const room = x.room === undefined ? {} : obj(x.room, "room"), desk = x.desk === undefined ? {} : obj(x.desk, "desk");
     keys(room, ["floor", "wall"], "room"); keys(desk, ["back", "front", "lit"], "desk");
     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, straight: x.straight === true, furniture, characters, byInstance,
+      door: x.door === undefined ? { x: LOGICAL.w / 2, y: LOGICAL.h - 10 } : point(x.door, "door"),
+      mailDrop: x.mailDrop === undefined ? null : point(x.mailDrop, "mailDrop"), 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") },
+      ...(levels ? { levels } : {}),
     } };
   } catch (err) {
     if (err instanceof Refused) return { ok: false, error: err.message };
@@ -337,11 +433,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", "mailDrop", "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) {
@@ -366,7 +468,38 @@ 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.mailDrop !== undefined) { const q = point(x.mailDrop, "overrides.mailDrop"); out.mailDrop = [q.x, q.y]; }
     if (x.edges !== undefined && x.waypoints === undefined) throw new Refused("overrides.edges", "only with waypoints");
     if (x.waypoints !== undefined) {
       const ids = new Set();
@@ -408,21 +541,68 @@ 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 mailDrop = ov.mailDrop ? { x: ov.mailDrop[0], y: ov.mailDrop[1] } : pack.mailDrop ?? null;
     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 } };
+    return { ok: true, pack: { ...pack, areas, furniture, door, mailDrop, ...graph } };
   } catch (err) {
     if (err instanceof Refused) return { ok: false, error: err.message };
     throw err;
   }
 }
 
+/**
+ * #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).
@@ -431,12 +611,26 @@ 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];
+  // #2736: a mail drop placed (the pack has none) or moved from the pack's.
+  const md = pack.mailDrop ?? null, ed = edited.mailDrop ?? null;
+  if (ed && (!md || md.x !== ed.x || md.y !== ed.y)) ov.mailDrop = [ed.x, ed.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 }));
     ov.edges = edited.edges.map((e) => [e[0], e[1]]);

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

@@ -13,8 +13,9 @@
 // @typedef {"working"|"idle"|"paused"|"needs"|"walk"} OfficePose   (fleet-office-model.js POSES; "away" draws no one)
 // @typedef {{ pal: OfficePalette, mode: "dark"|"light", labels: { lobby, closed, areas: { [area]: string } } }} OfficeEnv
 // @typedef {{ name: string, label: string, state: string, pose: OfficePose|"away", light: "warn"|"danger"|null,
-//   lamp: boolean, sign: "closed"|null, coat: string, work: number, dim: boolean, match: boolean, free: boolean }} OfficeLook
-//   (one occupant; `free`: standing in a zone, not behind a desk cell)
+//   lamp: boolean, sign: "closed"|null, coat: string, work: number, dim: boolean, match: boolean, free: boolean,
+//   badge?: { text, tier } | { mark: true } }} OfficeLook
+//   (one occupant; `free`: standing in a zone, not behind a desk cell; `badge`: its level on its name tag, #2661)
 // @typedef {object} OfficeSkin
 // @property {string} id
 // @property {object} [pack]        a checked pack (fleet-office-pack.js); with `pack.stateZones` the zones layout is used
@@ -44,15 +45,18 @@
 import { t } from "/assets/app-i18n.js";
 import { frameAt, nameHash } from "./fleet-office-model.js";
 import { CHAR_DEPTH, LOGICAL, checkSkinPack, own, packImages, poseStrip, stripBox, walkStrip } from "./fleet-office-pack.js";
+import { tierColours } from "./fleet-office-levels.js";
 
 export { nameHash };
 
 // ── The palette: the dashboard's tokens, read by the renderer; furniture keeps its own wood and metal ──
 
-/** @typedef {{ bg, surface, surface2, border, text, text2, text3, ok, warn, danger, focus, fx: { task, send, report, broadcast } }} OfficePalette */
+/** @typedef {{ bg, surface, surface2, border, text, text2, text3, ok, warn, danger, focus, accent, accentDim, okBg, warnBg, dangerBg, fx: { task, send, report, broadcast } }} OfficePalette */
 export const DEFAULT_PAL = {
   bg: "#212121", surface: "#2f2f2f", surface2: "#3a3a3a", border: "#3d3d3d", text: "#ececec", text2: "#b4b4b4", text3: "#a3a3a3",
   ok: "#4cc38a", warn: "#e3b341", danger: "#ff8a80", focus: "#7ab7ff", fx: { task: "#b794f6", send: "#2dd4bf", report: "#f472b6", broadcast: "#fb923c" },
+  // #2661: the level badges' tiers (the status tokens and their tints).
+  accent: "#7ab7ff", accentDim: "rgba(122, 183, 255, 0.14)", okBg: "rgba(76, 195, 138, 0.14)", warnBg: "rgba(227, 179, 65, 0.14)", dangerBg: "rgba(255, 138, 128, 0.14)",
 };
 /** Light or dark, from the page's own background token (whatever chose it: the person, the system, a theme). */
 export function modeOf(pal) {
@@ -235,6 +239,7 @@ function drawDeskFront(ctx, d, look, env) {
     ctx.fillText(fitText(ctx, look.label, d.w - 18), d.x + d.w / 2, d.y + 86.5);
   }
   ctx.restore();
+  if (!look.notag && look.badge) drawBadge(ctx, d.x + 6, d.y + 78, look.badge, pal);
   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(); }
 }
 
@@ -296,6 +301,36 @@ export function tagBox(ctx, x, y, label) {
   ctx.restore();
   return { x: Math.round(x - w / 2), y: y + 3, w, h: 14, text: t };
 }
+/**
+ * #2661: a level badge on a name tag's top-left corner (x, y: the tag's corner), overlapping its edge like an app's
+ * badge — it takes none of the tag's width. `badge`: { text, tier } (fleet-office-levels.js badgeOf), or { mark } for a
+ * pinned title that hides the number: a small diamond.
+ */
+export function drawBadge(ctx, x, y, badge, pal) {
+  if (!badge) return;
+  const c = tierColours(badge.tier, pal);
+  ctx.save();
+  ctx.globalAlpha = 1;
+  if (badge.mark) {
+    ctx.translate(x, y); ctx.rotate(Math.PI / 4);
+    ctx.fillStyle = pal.surface; ctx.fillRect(-4, -4, 8, 8);
+    ctx.fillStyle = c.bg; ctx.fillRect(-4, -4, 8, 8);
+    ctx.strokeStyle = c.line; ctx.lineWidth = 1; ctx.strokeRect(-3.5, -3.5, 7, 7);
+    ctx.restore();
+    return;
+  }
+  ctx.font = BADGE_FONT;
+  const w = Math.max(12, Math.ceil((ctx.measureText ? ctx.measureText(badge.text).width : badge.text.length * 5) + 6)), h = 11;
+  const bx = Math.round(x - w / 2 + 3), by = Math.round(y - h / 2 - 1);
+  // An opaque surface first, so a tint reads the same over any picture.
+  ctx.fillStyle = pal.surface; ctx.fillRect(bx, by, w, h);
+  ctx.fillStyle = c.bg; ctx.fillRect(bx, by, w, h);
+  ctx.strokeStyle = c.line; ctx.lineWidth = 1; ctx.strokeRect(bx + 0.5, by + 0.5, w - 1, h - 1);
+  ctx.fillStyle = c.fg; ctx.textAlign = "center"; ctx.textBaseline = "middle"; ctx.fillText(badge.text, bx + w / 2, by + h / 2 + 0.5);
+  ctx.restore();
+}
+const BADGE_FONT = "700 8px system-ui, sans-serif";
+
 /** Zones: a name tag under someone's feet at (x, y). */
 function drawTag(ctx, x, y, look, env) {
   const { pal } = env;
@@ -307,6 +342,7 @@ function drawTag(ctx, x, y, look, env) {
   ctx.strokeStyle = look.match ? pal.focus : pal.border; ctx.lineWidth = look.match ? 2 : 1; ctx.strokeRect(Math.round(x - w / 2) + 0.5, y + 3.5, w - 1, 13);
   ctx.fillStyle = pal.text; ctx.textAlign = "center"; ctx.textBaseline = "middle"; ctx.fillText(t, x, y + 10.5);
   ctx.restore();
+  if (look.badge) drawBadge(ctx, Math.round(x - w / 2), y + 3, look.badge, pal);
 }
 
 /**

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

@@ -1,14 +1,20 @@
 // The Office view's data, behind one small seam (fleet-office.js uses only these calls):
 // - the offices people made: the host's (GET / PUT /ui/offices, src/web-office-store.ts — one list for every viewer);
 //   what comes back is checked again here (fleet-office-model.js officesOk), never trusted;
+// - #2716: the whole-fleet office's style, kept on the host for everyone (GET /ui/offices's autoSkin; PUT
+//   /ui/office-style, an admin's) — this browser's own pick (skin(): an admin's copy of it, anyone else's own choice);
 // - this browser's own choices (localStorage; blocked storage: this page only, as the canvas's Canvas/List): which
-//   office is shown, the auto office's member filter, and its style (skin); #2540: the view (zoom and centre) and the
+//   office is shown, the auto office's member filter; #2540: the view (zoom and centre) and the
 //   fit mode (Fit or Fill) per office; #2554: whether All offices shows the lobby tile.
 // - the skin packs an admin uploaded (#2513: GET /ui/office-skins, POST to upload one, DELETE to remove one;
 //   src/web-office-skins.ts). The office editor and the layout editor call saveOffices() with the whole list and the rev
 //   they read (a change in between answers 409).
+// - #2661: everyone's level (GET /ui/office-levels, src/office-levels.ts; fleet-office-levels.js levelsOk checks it).
+// - #2692: the agents' pack changes (GET / POST /ui/office-pack-changes, an admin's): which agents may change packs, the
+//   fleet's approval mode, the changes waiting for a yes, and the newest log entries.
 import { AUTO_ID, filterOk, officesOk } from "./fleet-office-model.js";
 import { fitModeOk, savedOk } from "./fleet-office-view.js";
+import { levelsOk } from "./fleet-office-levels.js";
 
 const CHOICE_KEY = "agend_org_office", FILTER_KEY = "agend_org_office_filter", SKIN_KEY = "agend_org_office_skin", ASLEEP_KEY = "agend_org_office_hide_asleep", NIGHT_KEY = "agend_org_office_night";
 /** #2554: "0" when All offices leaves the lobby tile out (default: shown). */
@@ -18,6 +24,19 @@ const VIEW_KEY = "agend_org_office_view", VIEWS_MAX = 32;
 /** #2540: { "<office>@<style>": "cover" } — the offices whose fit fills the panel (the rest: "contain"), the last VIEWS_MAX. */
 const FIT_KEY = "agend_org_office_fit";
 const PACK_ID = /^[A-Za-z0-9_-]{1,40}$/;
+/** #2692: GET /ui/office-pack-changes, checked: { approval, agents: [names], pending: [views], log: [entries] } (anything odd dropped). */
+export function packChangesOk(d) {
+  const str = (v, n = 200) => (typeof v === "string" ? v.slice(0, n) : "");
+  const approval = d && (d.approval === "apply" || d.approval === "approve") ? d.approval : "approve";
+  const agents = Array.isArray(d && d.agents) ? d.agents.filter((n) => typeof n === "string" && n).slice(0, 500).map((n) => n.slice(0, 200)) : [];
+  const pending = (Array.isArray(d && d.pending) ? d.pending.slice(0, 32) : []).filter((v) => v && /^[0-9a-f]{32}$/.test(String(v.id)) && typeof v.instance === "string")
+    .map((v) => ({ id: v.id, instance: str(v.instance), action: str(v.action, 20), at: Number(v.at) || 0, expires_at: Number(v.expires_at) || 0,
+      packs: (Array.isArray(v.packs) ? v.packs.slice(0, 16) : []).filter((p) => p && typeof p.id === "string").map((p) => ({ id: str(p.id, 40), name: str(p.name, 60) || str(p.id, 40), files: Number(p.files) || 0, bytes: Number(p.bytes) || 0, replaces: typeof p.replaces === "string" ? p.replaces.slice(0, 32) : null })),
+      office: str(v.office, 40), style: str(v.style, 40), keep_previous: v.keep_previous === true, drops: Array.isArray(v.drops) ? v.drops.length : 0 }));
+  const log = (Array.isArray(d && d.log) ? d.log.slice(0, 50) : []).filter((e) => e && typeof e.at === "string")
+    .map((e) => ({ at: str(e.at, 40), by: str(e.by), action: str(e.action, 20), pack: str(e.pack, 200), outcome: str(e.outcome), files: Number(e.files) || 0, bytes: Number(e.bytes) || 0, approved_by: str(e.approved_by) }));
+  return { approval, agents, pending, log };
+}
 /** The host's list of skin packs, checked: [{ id, name, sha }] (anything odd dropped). */
 export function skinListOk(d) {
   const out = [], ids = new Set();
@@ -50,15 +69,26 @@ export function createOfficeStore({ fetch: get = globalThis.fetch, storage } = {
   const write = (k, v) => { try { const s = st(); if (s) s.setItem(k, v); } catch { /* this page only */ } };
   const headers = { "Content-Type": "application/json" };
   return {
-    /** { rev, offices } from the host; null when it could not be read (no offices shown but the auto one). */
+    /**
+     * { rev, offices, autoSkin } from the host (#2716 autoSkin: the whole-fleet office's style, or null: none kept); null
+     * when it could not be read (no offices shown but the auto one).
+     */
     async offices() {
       try {
         const r = await get("/ui/offices", { method: "GET", headers });
         if (!r || !r.ok) return null;
         const d = await r.json();
-        return { rev: Number.isSafeInteger(d && d.rev) ? d.rev : 0, offices: officesOk(d && d.offices) };
+        return { rev: Number.isSafeInteger(d && d.rev) ? d.rev : 0, offices: officesOk(d && d.offices), autoSkin: d && typeof d.autoSkin === "string" && PACK_ID.test(d.autoSkin) ? d.autoSkin : null };
       } catch { return null; }
     },
+    /** #2716: the whole-fleet office's style for everyone (an admin session): { ok, autoSkin } or { ok: false, status, error }. */
+    async saveAutoSkin(skin) {
+      try {
+        const r = await get("/ui/office-style", { method: "PUT", headers, body: JSON.stringify({ skin }) });
+        const d = await r.json().catch(() => ({}));
+        return r.ok ? { ok: true, autoSkin: typeof d.autoSkin === "string" ? d.autoSkin : null } : { ok: false, status: r.status, error: d.error || "office_style_failed" };
+      } catch { return { ok: false, status: 0, error: "office_style_failed" }; }
+    },
     /**
      * Replace the host's list (an admin session; `rev`: the one read — required: the host refuses a save without it,
      * so two editors never overwrite each other unseen). { ok, rev, offices } or { ok: false, status, error }.
@@ -80,6 +110,17 @@ export function createOfficeStore({ fetch: get = globalThis.fetch, storage } = {
         return actsOk(d && d.acts, d && d.now);
       } catch { return null; }
     },
+    /**
+     * #2661: everyone's level (GET /ui/office-levels; a share link's own, through its lease), checked (levelsOk); null
+     * when it could not be read (the levels shown stay).
+     */
+    async levels() {
+      try {
+        const r = await get("/ui/office-levels", { method: "GET", headers });
+        if (!r || !r.ok) return null;
+        return levelsOk(await r.json());
+      } catch { return null; }
+    },
     /** The skin packs the host keeps: { rev, packs: [{ id, name, sha }] }; null when they could not be read. */
     async skins() {
       try {
@@ -105,6 +146,34 @@ export function createOfficeStore({ fetch: get = globalThis.fetch, storage } = {
         return r.ok ? { ok: true } : { ok: false, status: r.status, error: d.error || "skin_failed" };
       } catch { return { ok: false, status: 0, error: "skin_failed" }; }
     },
+    /**
+     * #2692: the agents' skin-pack changes (an admin session): { approval, agents, pending, log }, or null (not offered,
+     * not an admin, not read).
+     */
+    async packChanges() {
+      try {
+        const r = await get("/ui/office-pack-changes", { method: "GET", headers });
+        if (!r || !r.ok) return null;
+        return packChangesOk(await r.json());
+      } catch { return null; }
+    },
+    /** #2692: the fleet's approval mode for agents' pack changes ("apply" | "approve"). */
+    async setPackApproval(approval) {
+      try {
+        const r = await get("/ui/office-pack-changes", { method: "POST", headers, body: JSON.stringify({ approval }) });
+        const d = await r.json().catch(() => ({}));
+        return r.ok ? { ok: true, changes: packChangesOk(d) } : { ok: false, status: r.status, error: d.error || "pack_changes_failed" };
+      } catch { return { ok: false, status: 0, error: "pack_changes_failed" }; }
+    },
+    /** #2692: an admin's yes or no on a pending pack change: { ok, text } or { ok: false, status, error, detail }. */
+    async decidePackChange(id, decision) {
+      if (!/^[0-9a-f]{32}$/.test(String(id))) return { ok: false, status: 0, error: "change_unknown", detail: "" };
+      try {
+        const r = await get(`/ui/office-pack-changes/${id}`, { method: "POST", headers, body: JSON.stringify({ decision }) });
+        const d = await r.json().catch(() => ({}));
+        return r.ok ? { ok: true, text: String(d.text || "") } : { ok: false, status: r.status, error: d.error || "pack_changes_failed", detail: String(d.detail || "") };
+      } catch { return { ok: false, status: 0, error: "pack_changes_failed", detail: "" }; }
+    },
     /**
      * The office shown here: an id (one the host no longer has falls back to the auto office where it is used), or
      * #2554's All offices (fleet-office-overview.js ALL_ID; with fewer than two offices stored: the auto office).
@@ -115,6 +184,8 @@ export function createOfficeStore({ fetch: get = globalThis.fetch, storage } = {
     saveFilter: (f) => write(FILTER_KEY, JSON.stringify(filterOk(f))),
     /** The whole fleet's style here: a skin id ("pixel": desks, "studio" and "cozy": zones); none chosen yet: cozy (#2631); an unknown one is the default where used. */
     skin: () => { const v = read(SKIN_KEY); return typeof v === "string" && /^[A-Za-z0-9_-]{1,40}$/.test(v) ? v : "cozy"; },
+    /** #2716: this browser's own pick of it, or null (none made here). */
+    skinChosen: () => { const v = read(SKIN_KEY); return typeof v === "string" && /^[A-Za-z0-9_-]{1,40}$/.test(v) ? v : null; },
     saveSkin: (id) => write(SKIN_KEY, String(id)),
     /** Whether paused and stopped people are left out of the Office here (default: shown). */
     hideAsleep: () => read(ASLEEP_KEY) === "1",