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

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

@@ -0,0 +1,167 @@
+// #2554: the Office view's "All offices" — every stored office as a tile on one canvas, side by side, each drawn exactly
+// as its own view would be (its style, its members, seats, poses, bubbles, walking), scaled into its tile. This module
+// is the pure part (fleet-office.js draws it): who is in no office (the lobby tile), where the tiles go, what a point
+// on the overview hits, which tiles are on screen, and the traffic that crosses between tiles.
+//
+// - Shown when at least two offices are stored (overviewOk); an id no stored office can have (ALL_ID: '*' is not an
+//   office id's character), kept per device as any office pick is.
+// - The tiles: each as large as its office's drawn content — a zones scene its 1280×720, a desks office its rooms'
+//   bounds (cropToRooms: an office of three is small) — scaled down to at most CELL_W × CELL_H, never up; a LABEL band
+//   above each (the page's label sits there), GAP apart, M from the edge. Shelf packing in the stored order (the lobby
+//   last): a row takes tiles while they fit a row width, each row as tall as its tallest tile and centred across. The
+//   row width: whichever (of the widths a run of tiles makes) lets the whole overview show largest in the panel (Fit's
+//   contain); a tie keeps the narrower. The same input always gives the same picture.
+// - Traffic between people in different tiles is a straight flight between their seats in overview coordinates
+//   (createCrossFlights); between two people in the same tile it is that tile's own (createFlights, along its corridors).
+import { FLIGHT, along, desksOf, membersOf, pathLength } from "./fleet-office-model.js";
+import { hue } from "./fleet-traffic.js";
+
+/** The switcher's "All offices" value: '*' is never in a stored office's id (fleet-office-model.js officeOk). */
+export const ALL_ID = "*all";
+/** The lobby tile's key: never an office's id. */
+export const LOBBY_TILE = "\u0000lobby";
+/** The overview's geometry, in logical units. */
+export const OV = { CELL_W: 1280, CELL_H: 720, LABEL: 56, GAP: 24, M: 24 };
+
+/** Whether "All offices" is offered: at least two stored offices. */
+export const overviewOk = (stored) => Array.isArray(stored) && stored.length >= 2;
+
+/**
+ * The people in no stored office, in the org chart's order (General, the teams, the rest): the lobby tile's. An office
+ * with no members holds everyone (fleet-office-model.js membersOf), so then nobody is left for the lobby.
+ */
+export function lobbyNodes(stored, view) {
+  const placed = new Set((stored || []).flatMap((o) => membersOf(o, view).map((n) => n.name)));
+  const out = new Map();
+  for (const n of [...view.top, ...view.teams.flatMap((tm) => tm.nodes), ...view.rest.nodes]) if (!placed.has(n.name) && !out.has(n.name)) out.set(n.name, n);
+  return [...out.values()];
+}
+
+/** A scene's scale in its tile: its own size, scaled down to fit a CELL_W × CELL_H cell (never up). */
+export const tileScale = (w, h) => Math.min(1, OV.CELL_W / Math.max(1, w), OV.CELL_H / Math.max(1, h));
+
+/**
+ * A desks layout cropped to its rooms: everything moved so the rooms' bounds start at (0, 0), its size theirs (the
+ * corridors outside the rooms and the margins are not part of a tile). Unchanged when it has no rooms.
+ */
+export function cropToRooms(L) {
+  if (!L.rooms.length) return L;
+  const x0 = Math.min(...L.rooms.map((r) => r.x)), y0 = Math.min(...L.rooms.map((r) => r.y));
+  const x1 = Math.max(...L.rooms.map((r) => r.x + r.w)), y1 = Math.max(...L.rooms.map((r) => r.y + r.h));
+  const mv = (p) => ({ ...p, x: p.x - x0, y: p.y - y0 });
+  return { ...L, rooms: L.rooms.map((r) => ({ ...mv(r), desks: r.desks.map((d) => ({ ...mv(d), seat: mv(d.seat) })) })), waypoints: (L.waypoints || []).map(mv),
+    width: x1 - x0, height: y1 - y0 };
+}
+
+/**
+ * The tiles of `scenes` ([{ key, w, h }], in order) on shelves at most `rowW` wide (a tile wider than that has a row of
+ * its own): each { key, x, y, w, h, s (its scale), label: { x, y, w, h } (the band above it) }; and the overview's size.
+ * Each row is centred across the widest; its tiles stand at its top, under their labels.
+ */
+export function arrangeTiles(scenes, rowW) {
+  const { LABEL, GAP, M } = OV;
+  const rows = [];
+  let row = null;
+  for (const sc of scenes) {
+    const s = tileScale(sc.w, sc.h), it = { key: sc.key, s, w: Math.max(1, sc.w) * s, h: Math.max(1, sc.h) * s };
+    if (!row || row.w + GAP + it.w > rowW + 1e-6) { row = { items: [], w: -GAP, h: 0 }; rows.push(row); }
+    row.items.push(it); row.w += GAP + it.w; row.h = Math.max(row.h, it.h);
+  }
+  const inner = rows.length ? Math.max(...rows.map((r) => r.w)) : 0, tiles = [];
+  let y = M;
+  for (const r of rows) {
+    let x = M + (inner - r.w) / 2;
+    for (const it of r.items) {
+      tiles.push({ key: it.key, x, y: y + LABEL, w: it.w, h: it.h, s: it.s, label: { x, y, w: it.w, h: LABEL } });
+      x += it.w + GAP;
+    }
+    y += LABEL + r.h + GAP;
+  }
+  return { rows: rows.length, rowW, tiles, width: 2 * M + inner, height: rows.length ? y - GAP + M : 2 * M };
+}
+
+/**
+ * The tiles packed for a `size` panel: of the row widths a run of consecutive tiles makes, the one whose overview shows
+ * largest there (min of the two fits); a tie keeps the narrower.
+ */
+export function tileLayout(scenes, size) {
+  const ws = scenes.map((sc) => Math.max(1, sc.w) * tileScale(sc.w, sc.h)), cands = new Set();
+  for (let i = 0; i < ws.length; i++) { let run = -OV.GAP; for (let j = i; j < ws.length; j++) { run += OV.GAP + ws[j]; cands.add(run); } }
+  let best = arrangeTiles(scenes, 0), bestK = -1;
+  for (const rowW of [...cands].sort((a, b) => a - b)) {
+    const a = arrangeTiles(scenes, rowW), k = Math.min(size.w / a.width, size.h / a.height);
+    if (k > bestK + 1e-9) { best = a; bestK = k; }
+  }
+  return best;
+}
+
+/** The tile whose scene holds the overview point (x, y), or null. */
+export const tileAt = (lay, x, y) => lay.tiles.find((t) => x >= t.x && x < t.x + t.w && y >= t.y && y < t.y + t.h) || null;
+/** The tile whose label band holds the overview point, or null. */
+export const labelAt = (lay, x, y) => lay.tiles.find((t) => x >= t.label.x && x < t.label.x + t.label.w && y >= t.label.y && y < t.label.y + t.label.h) || null;
+/** Overview → the tile's own scene units, and back; a box in the scene → the overview. */
+export const inTile = (t, x, y) => ({ x: (x - t.x) / t.s, y: (y - t.y) / t.s });
+export const fromTile = (t, p) => ({ x: t.x + p.x * t.s, y: t.y + p.y * t.s });
+export const tileBox = (t, b) => ({ x: t.x + b.x * t.s, y: t.y + b.y * t.s, w: b.w * t.s, h: b.h * t.s });
+/** The tiles a view ({ k, x, y }) shows any of in a `size` viewport: the rest are not drawn. */
+export function visibleTiles(lay, v, size) {
+  return lay.tiles.filter((t) => {
+    const x = v.x + t.x * v.k, y = v.y + t.y * v.k;
+    return x < size.w && x + t.w * v.k > 0 && y < size.h && y + t.h * v.k > 0;
+  });
+}
+
+/**
+ * A straight flight between two people in different tiles: [the sender's seat, the receiver's] in overview units (the
+ * first tile each is in), or null — when either is drawn nowhere, or some tile holds both (that tile carries it along
+ * its corridors). `parts`: [{ tile, L }] in the tiles' order.
+ */
+export function crossPath(parts, from, to) {
+  let a = null, z = null;
+  for (const p of parts) {
+    const ds = desksOf(p.L), da = ds.find((d) => d.node.name === from), dz = ds.find((d) => d.node.name === to);
+    if (da && dz) return null;
+    if (da && !a) a = fromTile(p.tile, da.seat);
+    if (dz && !z) z = fromTile(p.tile, dz.seat);
+  }
+  return a && z ? [a, z] : null;
+}
+
+const MAX_SEEN = 2000;
+/**
+ * The items in the air between tiles — fleet-office-model.js createFlights's lifecycle (each new item once; none for a
+ * stale delegation or with reduced motion), on crossPath's straight line: `frame(now, parts)` → { id, hue, kind, from, x, y,
+ * t } in overview units; a trip with no crossing (both in one tile, or either gone) is dropped.
+ */
+export function createCrossFlights({ max = FLIGHT.MAX } = {}) {
+  const seen = new Set();
+  let trips = [];
+  return {
+    sync(items, now, still = false) {
+      let k = 0, started = 0;
+      for (const it of items || []) {
+        if (seen.has(it.id)) continue;
+        seen.add(it.id);
+        if (seen.size > MAX_SEEN) seen.delete(seen.values().next().value);
+        if (still || it.phase === "stale") continue;
+        trips.push({ id: it.id, from: it.from, to: it.to, kind: it.kind, hue: hue(it.kind), start: now + k++ * FLIGHT.STAGGER_MS, parts: null, pts: null, ms: 0 });
+        started++;
+      }
+      if (trips.length > max) trips = trips.slice(trips.length - max);
+      return started;
+    },
+    frame(now, parts) {
+      const out = [];
+      trips = trips.filter((f) => {
+        if (f.parts !== parts) { f.parts = parts; f.pts = crossPath(parts, f.from, f.to); f.ms = f.pts ? Math.min(FLIGHT.MAX_MS, Math.max(FLIGHT.MIN_MS, pathLength(f.pts) / FLIGHT.SPEED)) : 0; }
+        if (!f.pts) return false;
+        const t = (now - f.start) / f.ms;
+        if (t >= 1) return false;
+        if (t >= 0) { const p = along(f.pts, t); out.push({ id: f.id, hue: f.hue, kind: f.kind, from: f.from, x: p.x, y: p.y, t }); }
+        return true;
+      });
+      return out;
+    },
+    size: () => trips.length,
+  };
+}

package/dist/ui/fleet-office-pack.d.ts

@@ -4,7 +4,8 @@
 export interface PackStrip { src: string; frames: number; w: number; h: number; fps: number; ax: number; ay: number; dw: number; dh: number }
 export interface PackPoint { x: number; y: number }
 export interface PackArea { name: string; rect: { x: number; y: number; w: number; h: number }; seats: PackPoint[] }
-export interface PackFurniture { id: string; sprite: PackStrip; x: number; y: number; depth: number | "y"; activeWhen: string[] | null; activeSprite: PackStrip | null }
+/** `label` (#2574): its name tag, or null. */
+export interface PackFurniture { id: string; sprite: PackStrip; x: number; y: number; depth: number | "y"; activeWhen: string[] | null; activeSprite: PackStrip | null; label: string | null }
 export interface CheckedPack {
   format: 1; id: string; scale: number; background?: string; foreground?: string; matte?: string;
   areas: Record<string, PackArea>; stateZones: Record<string, string> | null; door: PackPoint;
@@ -17,6 +18,8 @@ export interface LayoutOverrides {
   pack: string;
   seats?: Record<string, Array<[number, number]>>;
   furniture?: Record<string, [number, number]>;
+  /** #2665: an item's night place (an item with a `night` only). */
+  furnitureNight?: Record<string, [number, number]>;
   door?: [number, number];
   waypoints?: Array<{ id: string; x: number; y: number }>;
   edges?: Array<[string, string]>;
@@ -28,12 +31,14 @@ export function own<T = unknown>(o: unknown, k: unknown): T | undefined;
 export function inherited(k: unknown): boolean;
 export function matteOk(v: unknown): v is string;
 export function checkStrip(v: unknown, at?: string, scale?: number): PackStrip;
-export function checkSkinPack(x: unknown): { ok: true; pack: CheckedPack } | { ok: false; error: string };
+export function checkSkinPack(x: unknown, opts?: { kept?: boolean }): { ok: true; pack: CheckedPack } | { ok: false; error: string };
 export function skinPackOk(x: unknown): CheckedPack | null;
 export function packImages(pack: CheckedPack): string[];
 export function packStrips(pack: CheckedPack): Array<{ at: string; strip: PackStrip }>;
 export function checkLayoutOverrides(x: unknown): { ok: true; overrides: LayoutOverrides } | { ok: false; error: string };
 export function applyOverrides(pack: CheckedPack, ov: LayoutOverrides | null | undefined): { ok: true; pack: CheckedPack } | { ok: false; error: string };
+export function fitNight<T extends LayoutOverrides | null | undefined>(pack: CheckedPack, ov: T): T;
 export function overridesBetween(pack: CheckedPack, edited: CheckedPack): LayoutOverrides | null;
 export function poseStrip(set: Record<string, PackStrip> | null | undefined, pose: string, heading?: { dx: number; dy: number } | null): { strip: PackStrip; mirror: boolean } | null;
+export function walkStrip(f: { walk?: Record<string, PackStrip> | null; walking?: boolean; heading?: { dx: number; dy: number } | null } | null | undefined): { strip: PackStrip; mirror: boolean } | null;
 export function stripBox(st: PackStrip, x: number, y: number, mirror?: boolean): { x: number; y: number; w: number; h: number };

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

@@ -30,15 +30,32 @@
 //     "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 +64,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 +102,7 @@
 //   { "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)
 //     "door": [640, 700],
 //     "waypoints": [{ "id": "hall", "x": 640, "y": 600 }, …], "edges": [["hall", "east"], …] }
 //                                                     the walkable graph, replaced whole (edges need waypoints)
@@ -89,14 +110,26 @@
 // 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`
+// 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;
@@ -138,6 +171,24 @@ 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 8. */
+function names(v, at) {
+  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)];
+}
 function strips(v, names, at, scale) {
   obj(v, at);
   keys(v, names, at);
@@ -148,16 +199,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}`);
@@ -204,20 +259,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 +308,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 +321,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;
@@ -280,7 +345,7 @@ const OV_LIMIT = { areas: LIMIT.areas, seats: LIMIT.seats, furniture: LIMIT.furn
 export function checkLayoutOverrides(x) {
   try {
     obj(x, "overrides");
-    keys(x, ["pack", "seats", "furniture", "door", "waypoints", "edges"], "overrides");
+    keys(x, ["pack", "seats", "furniture", "furnitureNight", "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 +370,16 @@ 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.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) {
@@ -352,7 +427,13 @@ export function applyOverrides(pack, ov) {
     }
     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 +443,20 @@ 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;
+}
+
 /**
  * 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).
@@ -375,6 +470,12 @@ export function overridesBetween(pack, edited) {
   }
   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 +504,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;