@7365admin1/layer-common 4.49.0 → 4.51.0

package/utils/robot-building.ts

@@ -136,11 +136,12 @@ export function buildingFloors(robotFloors: number[], map?: Record<string, any>
 /* ============================================================ plan frame */
 
 /**
- * The HERO plan is drawn in shares of the floor (0-100); the API stores site
- * metres. The plan frame is fixed at 40 x 26 m (the 400 x 260 plane's shape),
- * so a saved shape lands in the same place every time it is opened.
- * ponytail: fixed frame; use the robot's reported plan extent once brands
- * report one (HERO-PENDING_INTEGRATIONS "Plan position").
+ * The HERO plan is drawn in shares of the floor (0-100); the API stores
+ * metres. A map saved before the building-file work used a fixed 40 x 26 m
+ * frame (decision 30) - `toMetres` / `toShare` and the legacy save body keep
+ * that frame so old maps open exactly where they were. The editor itself works
+ * in shares of the building's REAL frame (`TFrame`: world metres, any size),
+ * so a plan bigger than 40 x 26 m is no longer cut at the edge.
  */
 export const PLAN_W_M = 40;
 export const PLAN_H_M = 26;
@@ -148,12 +149,34 @@ const round2 = (n: number) => Math.round(n * 100) / 100;
 export const toMetres = (p: { x: number; y: number }): TMapPointM => ({ x: round2((p.x / 100) * PLAN_W_M), y: round2((p.y / 100) * PLAN_H_M) });
 export const toShare = (p: { x: number; y: number }) => ({ x: round2((p.x / PLAN_W_M) * 100), y: round2((p.y / PLAN_H_M) * 100) });
 
+/** The frame the editor draws: its top-left corner in world metres (y up) and its size. */
+export type TFrame = { minX: number; maxY: number; w: number; h: number };
+/** The frame of a map drawn before the building-file work: 40 x 26 m from the world origin. */
+export const DEFAULT_FRAME: TFrame = { minX: 0, maxY: 0, w: PLAN_W_M, h: PLAN_H_M };
+type TSize = { w: number; h: number };
+
 /* ================================================================ editor */
 
-export type TEditorTool = "wall" | "zone" | "door" | "lift" | "move" | "delete";
-export type TShapeKind = "wall" | "zone" | "door" | "lift";
+export type TEditorTool = "wall" | "zone" | "door" | "lift" | "move" | "delete" | "waypoint" | "lane" | "fiducial" | "measure";
+export type TShapeKind = "wall" | "zone" | "door" | "lift" | "waypoint" | "lane" | "fiducial" | "measure";
 
-/** One drawn element, in plan shares. A lift runs through `floors`; the rest sit on `floorNo`. */
+/**
+ * The robot-route tools, beside the drawing tools. Kept out of `MAP_TOOLS`
+ * (robot-display.ts), which is copied verbatim into the mobile apps.
+ */
+export const ROUTE_TOOLS: Array<{ id: TEditorTool; label: string }> = [
+  { id: "waypoint", label: "Waypoint" },
+  { id: "lane", label: "Lane" },
+  { id: "fiducial", label: "Fiducial" },
+  { id: "measure", label: "Measure" },
+];
+
+/**
+ * One drawn element, in plan shares. A lift runs through `floors`; the rest sit on `floorNo`.
+ * - waypoint / fiducial: one point; `name`; a waypoint's `meta.params` are its robot settings.
+ * - lane: two points copied from its waypoints `meta.from` / `meta.to` (kept in step by `syncLanes`).
+ * - measure: two points and `meta.distanceM`, the real length between them.
+ */
 export type TEditorShape = {
   id: string;
   kind: TShapeKind;
@@ -161,8 +184,8 @@ export type TEditorShape = {
   points: Array<{ x: number; y: number }>;
   name?: string;
   floors?: number[];
-  /** What the API had that the editor does not draw (door type), kept on save. */
-  meta?: Record<string, unknown>;
+  /** What the shape carries beyond its outline (door type and motion, lift angle and cabin doors, lane options...), kept on save. */
+  meta?: Record<string, any>;
 };
 
 /** A drag handle: the eight box handles (corners + edges). */
@@ -175,6 +198,14 @@ export type TDragOp =
   | { kind: "vertex"; id: string; index: number }
   | { kind: "rotate"; id: string };
 
+/** A route graph: one road network (Open-RMF graph_idx 0-8) and the robot brands that drive it. */
+export type TRouteGraph = { idx: number; name: string; brands: string[] };
+/** Where a floor-plan image sits: top-left at world (tx, -ty), `metersPerPixel`, turned `yawRad` about that corner. */
+export type TPlanPlacement = { metersPerPixel: number; tx: number; ty: number; yawRad?: number };
+
+/** What undo / redo put back: the drawing and everything saved with it. */
+type TSnapshot = { shapes: TEditorShape[]; frame: TFrame; graphs: TRouteGraph[]; plans: Record<string, TPlanPlacement> };
+
 export type TEditorState = {
   shapes: TEditorShape[];
   undo: string[];
@@ -188,10 +219,22 @@ export type TEditorState = {
   drag: { base: TEditorShape[]; op: TDragOp; x: number; y: number } | null;
   notice: { text: string; ok: boolean } | null;
   dirty: boolean;
+  /** The building's frame (every floor shares it). */
+  frame: TFrame;
+  /** The route graphs lanes belong to. */
+  graphs: TRouteGraph[];
+  /** Floor-plan placements changed here and not saved yet, by floor number. */
+  plans: Record<string, TPlanPlacement>;
+  /** Lane tool: the waypoint the next lane starts from. */
+  laneFrom: string | null;
+  /** Measure tool: the first end clicked. */
+  measureFrom: { x: number; y: number } | null;
+  /** The field last typed into - typing in one field is one undo step. */
+  lastEdit: string | null;
 };
 
 export type TEditorAction =
-  | { type: "place"; tool: TEditorTool; floorNo: number; x: number; y: number; zoneName?: string; floors?: number[]; id?: string }
+  | { type: "place"; tool: TEditorTool; floorNo: number; x: number; y: number; zoneName?: string; floors?: number[]; id?: string; name?: string }
   | { type: "pick"; id: string; tool: TEditorTool; zoneName?: string }
   | { type: "rename"; name: string }
   | { type: "tool"; tool?: TEditorTool }
@@ -200,6 +243,7 @@ export type TEditorAction =
   | { type: "notice"; text: string; ok: boolean }
   | { type: "saved"; text: string }
   | { type: "load"; shapes: TEditorShape[] }
+  | { type: "loadAll"; shapes: TEditorShape[]; frame: TFrame; graphs: TRouteGraph[]; notice?: TEditorState["notice"]; dirty?: boolean }
   | { type: "select"; ids: string[]; mode?: "replace" | "add" | "toggle" }
   | { type: "selectAll"; floorNo: number }
   | { type: "dragStart"; op: TDragOp; x: number; y: number }
@@ -214,15 +258,38 @@ export type TEditorAction =
   | { type: "flip" }
   | { type: "turn" }
   | { type: "addVertex"; id: string; x: number; y: number; within?: number }
-  | { type: "removeVertex"; id: string; index: number };
-
-/** The handoff's default sizes (shares of the plan): wall 16 x 1.5, zone 22 x 24, door 3, lift 8 x 14. */
-export const SHAPE_SIZE: Record<TShapeKind, { w: number; h: number }> = {
+  | { type: "removeVertex"; id: string; index: number }
+  /** Lane tool: a click on a waypoint (`hitId`) or on empty plan (a waypoint is made there). */
+  | { type: "laneClick"; floorNo: number; x: number; y: number; graphIdx: number; hitId?: string | null; id?: string; laneId?: string }
+  | { type: "laneEnd" }
+  /** Measure tool: first click marks one end, the second makes the measurement. */
+  | { type: "measureClick"; floorNo: number; x: number; y: number; id?: string }
+  /** The side panel: a shape's name, floors or meta (merged). Typing into one field is one undo step. */
+  | { type: "setProps"; id: string; name?: string; floors?: number[]; meta?: Record<string, any>; field?: string }
+  | { type: "graphs"; graphs: TRouteGraph[] }
+  /** Replace the drawing in one step (a route file merged in). */
+  | { type: "setShapes"; shapes: TEditorShape[]; graphs?: TRouteGraph[]; notice?: { text: string; ok: boolean } }
+  /** A new frame; every shape keeps its place in the building. `auto` (the area grown to fit a plan) is not an edit. */
+  | { type: "reframe"; frame: TFrame; auto?: boolean }
+  /** A floor plan re-placed (scale, position, turn) - saved with the map. */
+  | { type: "plan"; floorNo: number; placement: TPlanPlacement }
+  /** Move / scale / turn every shape on one floor (and its plan) by a transform in world metres: level alignment and scale-by-measurement. */
+  | { type: "transformFloor"; floorNo: number; t: { scale: number; rot: number; tx: number; ty: number }; placement?: TPlanPlacement | null };
+
+/** The handoff's default sizes (shares of the 40 x 26 m plan): wall 16 x 1.5, zone 22 x 24, door 3, lift 8 x 14. */
+export const SHAPE_SIZE: Record<"wall" | "zone" | "door" | "lift", { w: number; h: number }> = {
   wall: { w: 16, h: 1.5 },
   zone: { w: 22, h: 24 },
   door: { w: 3, h: 3 },
   lift: { w: 8, h: 14 },
 };
+/** The same sizes in metres, so a new shape is the same real size in any frame. */
+const SHAPE_SIZE_M: Record<"wall" | "zone" | "door" | "lift", { w: number; h: number }> = {
+  wall: { w: 6.4, h: 0.39 },
+  zone: { w: 8.8, h: 6.24 },
+  door: { w: 1.2, h: 0.78 },
+  lift: { w: 3.2, h: 3.64 },
+};
 
 export const TOOL_HINTS: Record<TEditorTool, string> = {
   wall: "Click to place a wall segment.",
@@ -231,6 +298,10 @@ export const TOOL_HINTS: Record<TEditorTool, string> = {
   lift: "Click to place a lift shaft; it runs through every floor.",
   move: "Click to select (Shift adds), drag to move, drag a handle to resize or turn. Drag on empty space to select an area. Shift while dragging turns snapping off.",
   delete: "Click a shape to delete it.",
+  waypoint: "Click to place a waypoint - a named spot robots drive to. Set its name and what it is (charger, parking...) on the right.",
+  lane: "Click a waypoint (or empty space) to start, then click the next one to draw a lane; keep clicking to chain. Esc or click the last waypoint again to stop.",
+  fiducial: "Click to place a fiducial - a mark you can find on every floor (a column corner). Give it the same name on each floor to line the floors up.",
+  measure: "Click both ends of a length you know (a wall, a doorway), then type its real length on the right.",
 };
 
 const clampShare = (n: number) => Math.max(0, Math.min(98, n));
@@ -240,17 +311,42 @@ const rect = (x: number, y: number, w: number, h: number) => [
   { x: x + w, y: y + h },
   { x, y: y + h },
 ];
+const inM = (p: { x: number; y: number }, f: TSize = DEFAULT_FRAME) => ({ x: (p.x * f.w) / 100, y: (p.y * f.h) / 100 });
+const inShare = (p: { x: number; y: number }, f: TSize = DEFAULT_FRAME) => ({ x: (p.x / f.w) * 100, y: (p.y / f.h) * 100 });
+const r2 = (p: { x: number; y: number }) => ({ x: round2(p.x), y: round2(p.y) });
+const r4 = (p: { x: number; y: number }) => ({ x: Math.round(p.x * 1e4) / 1e4, y: Math.round(p.y * 1e4) / 1e4 });
+/** Share rounding: 2 decimals in the 40 x 26 m frame (4 mm, as before); 4 decimals in a bigger one (under 5 mm up to 5 km). */
+const rs = (p: { x: number; y: number }, f: TSize = DEFAULT_FRAME) => (f.w > PLAN_W_M || f.h > PLAN_H_M ? r4(p) : r2(p));
+const clamp100 = (n: number) => Math.max(0, Math.min(100, n));
+/** A turn on screen (y down): positive = clockwise. */
+const rotS = (p: { x: number; y: number }, a: number) => ({ x: p.x * Math.cos(a) - p.y * Math.sin(a), y: p.x * Math.sin(a) + p.y * Math.cos(a) });
+const DEG = Math.PI / 180;
+/** An angle folded into -180..180 degrees (as radians). */
+const wrapRad = (a: number) => {
+  const t = ((((a + Math.PI) % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI)) - Math.PI;
+  return Math.round(t * 10000) / 10000;
+};
 
-/** The shape a click drops at (x, y): its top-left there, except a door, which centres on the click. */
-export function newShape(kind: TShapeKind, id: string, floorNo: number, x: number, y: number, extra: { name?: string; floors?: number[] } = {}): TEditorShape {
+/** The shape a click drops at (x, y): its top-left there, except a door, which centres on the click; a point shape sits on it. */
+export function newShape(
+  kind: TShapeKind,
+  id: string,
+  floorNo: number,
+  x: number,
+  y: number,
+  extra: { name?: string; floors?: number[] } = {},
+  f: TSize = DEFAULT_FRAME,
+): TEditorShape {
   const px = clampShare(x);
   const py = clampShare(y);
-  const { w, h } = SHAPE_SIZE[kind];
+  if (kind === "waypoint" || kind === "fiducial") return { id, kind, floorNo, points: [rs({ x: clamp100(x), y: clamp100(y) }, f)], name: (extra.name ?? "").trim() };
+  const size = SHAPE_SIZE_M[kind as keyof typeof SHAPE_SIZE_M] ?? SHAPE_SIZE_M.wall;
+  const { x: w, y: h } = inShare({ x: size.w, y: size.h }, f);
   const points =
     kind === "wall" ? [{ x: px, y: py + h / 2 }, { x: Math.min(100, px + w), y: py + h / 2 }]
       : kind === "door" ? [{ x: Math.max(0, px - w / 2), y: py }, { x: Math.min(100, px + w / 2), y: py }]
         : rect(px, py, Math.min(w, 100 - px), Math.min(h, 100 - py));
-  const shape: TEditorShape = { id, kind, floorNo, points };
+  const shape: TEditorShape = { id, kind, floorNo, points: points.map((q) => rs(q, f)) };
   if (kind === "zone") shape.name = (extra.name ?? "").trim();
   if (kind === "lift") shape.floors = extra.floors ?? [floorNo];
   return shape;
@@ -264,9 +360,9 @@ export function shapeBox(s: TEditorShape) {
   return { x, y, w: Math.max(...xs) - x, h: Math.max(...ys) - y };
 }
 
-/** A shape's anchor: a door's middle, a wall's start (top of its bar), otherwise the top-left corner. */
+/** A shape's anchor: a door's middle, a wall's start (top of its bar), a point's own place, otherwise the top-left corner. */
 function anchorOf(s: TEditorShape) {
-  if (s.kind === "door") {
+  if (s.kind === "door" || s.kind === "lane" || s.kind === "measure") {
     const [a, b] = s.points;
     return { x: ((a?.x ?? 0) + (b?.x ?? 0)) / 2, y: ((a?.y ?? 0) + (b?.y ?? 0)) / 2 };
   }
@@ -280,10 +376,17 @@ export function shapeAnchor(s: TEditorShape) {
   return { x: Math.round(a.x), y: Math.round(a.y) };
 }
 
-/** "Wall" · "Door" · "Lift shaft (all floors)" · "Zone · Lobby" / "Zone · unnamed" */
+const DOOR_TYPE_WORDS: Record<string, string> = { hinged: "single swing", double_hinged: "double swing", sliding: "single sliding", double_sliding: "double sliding" };
+
+/** "Wall" · "Door" · "Lift shaft (all floors)" · "Zone · Lobby" · "Waypoint · Lobby" · "Lane" · "Fiducial · F1" · "Measurement · 12.5 m" */
 export function shapeTitle(s: TEditorShape): string {
   if (s.kind === "zone") return `Zone · ${s.name || "unnamed"}`;
   if (s.kind === "lift") return "Lift shaft (all floors)";
+  if (s.kind === "waypoint") return s.name ? `Waypoint · ${s.name}` : "Waypoint";
+  if (s.kind === "fiducial") return `Fiducial · ${s.name || "unnamed"}`;
+  if (s.kind === "measure") return `Measurement · ${Number(s.meta?.distanceM ?? 0).toFixed(2)} m`;
+  if (s.kind === "lane") return s.meta?.bidirectional === false ? "Lane (one-way)" : "Lane (two-way)";
+  if (s.kind === "door" && s.meta?.type && s.meta.type !== "hinged" && s.meta.type !== "sliding") return `Door · ${DOOR_TYPE_WORDS[s.meta.type] ?? s.meta.type}`;
   return s.kind === "door" ? "Door" : "Wall";
 }
 
@@ -291,66 +394,97 @@ export function shapeTitle(s: TEditorShape): string {
 export const shapesOnFloor = (shapes: TEditorShape[], floorNo: number) =>
   shapes.filter((s) => s.kind === "lift" || s.floorNo === floorNo);
 
-export function emptyEditor(shapes: TEditorShape[] = []): TEditorState {
-  return { shapes, undo: [], redo: [], selected: [], vertex: null, drag: null, notice: null, dirty: false };
+export function emptyEditor(shapes: TEditorShape[] = [], extra: Partial<Pick<TEditorState, "frame" | "graphs">> = {}): TEditorState {
+  return {
+    shapes,
+    undo: [],
+    redo: [],
+    selected: [],
+    vertex: null,
+    drag: null,
+    notice: null,
+    dirty: false,
+    frame: extra.frame ?? { ...DEFAULT_FRAME },
+    graphs: extra.graphs ?? [],
+    plans: {},
+    laneFrom: null,
+    measureFrom: null,
+    lastEdit: null,
+  };
 }
 
-/* ---- editing geometry: the plan is in shares (0-100 each way); angles and distances are real metres ---- */
-
-const MX = PLAN_W_M / 100;
-const MY = PLAN_H_M / 100;
-const inM = (p: { x: number; y: number }) => ({ x: p.x * MX, y: p.y * MY });
-const inShare = (p: { x: number; y: number }) => ({ x: p.x / MX, y: p.y / MY });
-const r2 = (p: { x: number; y: number }) => ({ x: round2(p.x), y: round2(p.y) });
-const clamp100 = (n: number) => Math.max(0, Math.min(100, n));
+/* ---- editing geometry: the plan is in shares (0-100 each way) of the frame; angles and distances are real metres ---- */
 
 /** Lift shafts: what the API accepts (0.5-10 m a side). Zones: at least 0.5 m a side while resizing. */
 export const LIFT_MIN_M = 0.5;
 export const LIFT_MAX_M = 10;
 export const ZONE_MIN_M = 0.5;
 /** Grid steps offered (metres) and the default. */
-export const GRID_STEPS_M = [0.25, 0.5, 1, 2];
+export const GRID_STEPS_M = [0.25, 0.5, 1, 2, 5];
 export const DEFAULT_GRID_M = 1;
-/** Arrow-key nudge: 0.1 m, Shift 1 m. A door turn snaps to 15 degrees while snapping is on. */
+/** Arrow-key nudge: 0.1 m, Shift 1 m. A turn snaps to 15 degrees while snapping is on. */
 export const NUDGE_M = 0.1;
 export const NUDGE_BIG_M = 1;
 export const ROTATE_SNAP_DEG = 15;
 
-/** One grid step in shares across and down (the plan is 40 x 26 m). */
-export const gridShares = (stepM: number) => ({ x: (stepM / PLAN_W_M) * 100, y: (stepM / PLAN_H_M) * 100 });
+/** One grid step in shares across and down. */
+export const gridShares = (stepM: number, f: TSize = DEFAULT_FRAME) => ({ x: (stepM / f.w) * 100, y: (stepM / f.h) * 100 });
 
 /** The nearest grid crossing, in shares, inside the plan. No step = only rounded. */
-export function snapToGrid(p: { x: number; y: number }, stepM: number): { x: number; y: number } {
-  if (!(stepM > 0)) return r2({ x: clamp100(p.x), y: clamp100(p.y) });
-  const m = inM(p);
-  const q = inShare({ x: Math.round(m.x / stepM) * stepM, y: Math.round(m.y / stepM) * stepM });
-  return r2({ x: clamp100(q.x), y: clamp100(q.y) });
+export function snapToGrid(p: { x: number; y: number }, stepM: number, f: TSize = DEFAULT_FRAME): { x: number; y: number } {
+  if (!(stepM > 0)) return rs({ x: clamp100(p.x), y: clamp100(p.y) }, f);
+  const m = inM(p, f);
+  const q = inShare({ x: Math.round(m.x / stepM) * stepM, y: Math.round(m.y / stepM) * stepM }, f);
+  return rs({ x: clamp100(q.x), y: clamp100(q.y) }, f);
 }
 
 /** A dragged corner or end: onto another shape's corner or end within `toleranceM`, else the grid (if on). */
-export function snapPoint(p: { x: number; y: number }, gridM: number, targets: Array<{ x: number; y: number }>, toleranceM: number) {
-  const i = targets.length && toleranceM > 0 ? nearestPoint(inM(p), targets.map(inM), toleranceM) : -1;
-  return i >= 0 ? { ...targets[i]! } : snapToGrid(p, gridM);
+export function snapPoint(p: { x: number; y: number }, gridM: number, targets: Array<{ x: number; y: number }>, toleranceM: number, f: TSize = DEFAULT_FRAME) {
+  const i = targets.length && toleranceM > 0 ? nearestPoint(inM(p, f), targets.map((t) => inM(t, f)), toleranceM) : -1;
+  return i >= 0 ? { ...targets[i]! } : snapToGrid(p, gridM, f);
+}
+
+/** A lift shaft in metres: its centre, width (across), depth (down) and angle (world, anticlockwise). */
+export function liftGeom(s: TEditorShape, f: TSize = DEFAULT_FRAME) {
+  const b = shapeBox(s);
+  return { c: inM({ x: b.x + b.w / 2, y: b.y + b.h / 2 }, f), w: (b.w * f.w) / 100, d: (b.h * f.h) / 100, yaw: Number(s.meta?.yawRad ?? 0) };
+}
+
+/** A lift shaft's four corners in shares (turned by its angle). */
+export function liftCorners(s: TEditorShape, f: TSize = DEFAULT_FRAME) {
+  const g = liftGeom(s, f);
+  return [
+    { x: -g.w / 2, y: -g.d / 2 },
+    { x: g.w / 2, y: -g.d / 2 },
+    { x: g.w / 2, y: g.d / 2 },
+    { x: -g.w / 2, y: g.d / 2 },
+  ].map((q) => {
+    const r = rotS(q, -g.yaw);
+    return inShare({ x: g.c.x + r.x, y: g.c.y + r.y }, f);
+  });
 }
 
 /**
- * The shape under a point (shares): doors, then lift shafts, walls, then
- * zones (the smallest first); the newest first within a kind. Walls and doors
- * count within `toleranceM` of their line; a zone inside or near its edge.
+ * The shape under a point (shares): waypoints and fiducials, then doors and
+ * measurements, lift shafts, lanes, walls, then zones (the smallest first);
+ * the newest first within a kind. Lines count within `toleranceM`; a point
+ * within 1.5 times that; a zone inside or near its edge.
  */
-export function hitShape(shapes: TEditorShape[], p: { x: number; y: number }, toleranceM: number): TEditorShape | null {
-  const q = inM(p);
-  const rank: Record<TShapeKind, number> = { door: 0, lift: 1, wall: 2, zone: 3 };
+export function hitShape(shapes: TEditorShape[], p: { x: number; y: number }, toleranceM: number, f: TSize = DEFAULT_FRAME): TEditorShape | null {
+  const q = inM(p, f);
+  const rank: Record<TShapeKind, number> = { waypoint: 0, fiducial: 0, door: 1, measure: 1, lift: 2, lane: 3, wall: 4, zone: 5 };
   const hits = [...shapes].reverse().filter((s) => {
-    const pts = s.points.map(inM);
-    if (s.kind === "wall" || s.kind === "door") return pts.length > 1 && distanceToSegment(q, pts[0]!, pts[1]!) <= toleranceM;
+    const pts = s.points.map((t) => inM(t, f));
+    if (s.kind === "waypoint" || s.kind === "fiducial") return pts.length > 0 && Math.hypot(pts[0]!.x - q.x, pts[0]!.y - q.y) <= toleranceM * 1.5;
+    if (s.kind === "wall" || s.kind === "door" || s.kind === "measure" || s.kind === "lane") return pts.length > 1 && distanceToSegment(q, pts[0]!, pts[1]!) <= toleranceM;
     if (s.kind === "lift") {
-      const b = shapeBox(s);
-      return p.x >= b.x && p.x <= b.x + b.w && p.y >= b.y && p.y <= b.y + b.h;
+      const g = liftGeom(s, f);
+      const l = rotS({ x: q.x - g.c.x, y: q.y - g.c.y }, g.yaw);
+      return Math.abs(l.x) <= g.w / 2 && Math.abs(l.y) <= g.d / 2;
     }
     return pointInPolygon(q, pts) || pts.some((a, i) => distanceToSegment(q, a, pts[(i + 1) % pts.length]!) <= toleranceM);
   });
-  const area = (s: TEditorShape) => (s.kind === "zone" ? polygonArea(s.points.map(inM)) : 0);
+  const area = (s: TEditorShape) => (s.kind === "zone" ? polygonArea(s.points.map((t) => inM(t, f))) : 0);
   hits.sort((a, b) => rank[a.kind] - rank[b.kind] || area(a) - area(b));
   return hits[0] ?? null;
 }
@@ -383,6 +517,7 @@ const HANDLE_CURSOR: Record<THandle, string> = {
   nw: "nwse-resize", se: "nwse-resize", ne: "nesw-resize", sw: "nesw-resize", n: "ns-resize", s: "ns-resize", e: "ew-resize", w: "ew-resize",
 };
 const HANDLES: THandle[] = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+const handleSign = (h: THandle) => ({ x: h.includes("w") ? -1 : h.includes("e") ? 1 : 0, y: h.includes("n") ? -1 : h.includes("s") ? 1 : 0 });
 
 function boxHandles(s: TEditorShape): TShapeHandle[] {
   const b = shapeBox(s);
@@ -407,28 +542,42 @@ export function turnCentre(s: TEditorShape) {
 }
 
 /**
- * The handles one selected shape shows: a wall's two ends; a door's two ends
- * + a turn handle 2 m out on the side away from its swing; a lift shaft's
- * eight box handles + a turn handle above it; a zone's eight box handles + a
- * handle on every corner the box handles don't already cover.
+ * The handles one selected shape shows: a wall's or measurement's two ends; a
+ * door's two ends + a turn handle 2 m out on the side away from its swing; a
+ * lift shaft's eight box handles (turned with it) + a turn handle above it; a
+ * zone's eight box handles + a handle on every corner the box handles don't
+ * already cover. Waypoints, fiducials and lanes have none (they are dragged;
+ * a lane follows its waypoints).
  */
-export function shapeHandles(s: TEditorShape): TShapeHandle[] {
+export function shapeHandles(s: TEditorShape, f: TSize = DEFAULT_FRAME): TShapeHandle[] {
   const ends = (): TShapeHandle[] => s.points.map((p, i) => ({ key: `v${i}`, kind: "vertex", index: i, x: p.x, y: p.y, cursor: "move" }));
-  if (s.kind === "wall") return ends();
+  if (s.kind === "wall" || s.kind === "measure") return ends();
+  if (s.kind === "waypoint" || s.kind === "fiducial" || s.kind === "lane") return [];
   if (s.kind === "door") {
-    const [a, b] = s.points.map(inM);
+    const [a, b] = s.points.map((t) => inM(t, f));
     const len = Math.hypot(b!.x - a!.x, b!.y - a!.y) || 1;
-    const c = inM(turnCentre(s));
-    const t = inShare({ x: c.x - ((b!.y - a!.y) / len) * 2, y: c.y + ((b!.x - a!.x) / len) * 2 });
+    const c = inM(turnCentre(s), f);
+    // Opposite the swing: the swing opens to the left of start->end (world) for direction +1.
+    const side = Number(s.meta?.motionDirection ?? 1) < 0 ? -1 : 1;
+    const t = inShare({ x: c.x - ((b!.y - a!.y) / len) * 2 * side, y: c.y + ((b!.x - a!.x) / len) * 2 * side }, f);
     return [...ends(), { key: "rot", kind: "rotate", x: round2(clamp100(t.x)), y: round2(clamp100(t.y)), cursor: "grab" }];
   }
-  const box = boxHandles(s);
   if (s.kind === "lift") {
-    const b = shapeBox(s);
-    const gap = gridShares(1.5).y;
-    const y = b.y - gap >= 0 ? b.y - gap : b.y + b.h + gap;
-    return [...box, { key: "rot", kind: "rotate", x: round2(b.x + b.w / 2), y: round2(y), cursor: "grab" }];
+    const g = liftGeom(s, f);
+    const at = (lx: number, ly: number) => {
+      const r = rotS({ x: lx, y: ly }, -g.yaw);
+      return r2(inShare({ x: g.c.x + r.x, y: g.c.y + r.y }, f));
+    };
+    const box: TShapeHandle[] = HANDLES.map((h) => {
+      const k = handleSign(h);
+      return { key: h, kind: "resize", handle: h, ...at((k.x * g.w) / 2, (k.y * g.d) / 2), cursor: HANDLE_CURSOR[h] };
+    });
+    const gap = 1.5;
+    let rot = at(0, -g.d / 2 - gap);
+    if (rot.y < 0 || rot.y > 100 || rot.x < 0 || rot.x > 100) rot = at(0, g.d / 2 + gap);
+    return [...box, { key: "rot", kind: "rotate", x: rot.x, y: rot.y, cursor: "grab" }];
   }
+  const box = boxHandles(s);
   const corners = box.filter((h) => h.handle!.length === 2);
   const own = ends().filter((v) => !corners.some((c) => Math.abs(c.x - v.x) < 0.3 && Math.abs(c.y - v.y) < 0.3));
   return [...box, ...own];
@@ -445,99 +594,162 @@ export function resizeBox(
   p: { x: number; y: number },
   min: { w: number; h: number },
   max: { w: number; h: number } = { w: Infinity, h: Infinity },
+  bounds: { lo: number; hi: number } = { lo: 0, hi: 100 },
 ) {
   let x0 = b.x;
   let y0 = b.y;
   let x1 = b.x + b.w;
   let y1 = b.y + b.h;
-  if (handle.includes("w")) x0 = Math.min(Math.max(p.x, x1 - max.w, 0), x1 - min.w);
-  if (handle.includes("e")) x1 = Math.max(Math.min(p.x, x0 + max.w, 100), x0 + min.w);
-  if (handle.includes("n")) y0 = Math.min(Math.max(p.y, y1 - max.h, 0), y1 - min.h);
-  if (handle.includes("s")) y1 = Math.max(Math.min(p.y, y0 + max.h, 100), y0 + min.h);
+  if (handle.includes("w")) x0 = Math.min(Math.max(p.x, x1 - max.w, bounds.lo), x1 - min.w);
+  if (handle.includes("e")) x1 = Math.max(Math.min(p.x, x0 + max.w, bounds.hi), x0 + min.w);
+  if (handle.includes("n")) y0 = Math.min(Math.max(p.y, y1 - max.h, bounds.lo), y1 - min.h);
+  if (handle.includes("s")) y1 = Math.max(Math.min(p.y, y0 + max.h, bounds.hi), y0 + min.h);
   return { x: round2(x0), y: round2(y0), w: round2(x1 - x0), h: round2(y1 - y0) };
 }
 
-/** A lift shaft or zone resized from a box handle; a zone's corners scale with its box. */
-export function resizeShape(s: TEditorShape, handle: THandle, p: { x: number; y: number }): TEditorShape {
+/** A lift shaft or zone resized from a box handle; a zone's corners scale with its box; a turned shaft resizes along its own sides. */
+export function resizeShape(s: TEditorShape, handle: THandle, p: { x: number; y: number }, f: TSize = DEFAULT_FRAME): TEditorShape {
   const b = shapeBox(s);
   if (s.kind === "lift") {
-    const min = gridShares(LIFT_MIN_M);
-    const max = gridShares(LIFT_MAX_M);
-    const n = resizeBox(b, handle, p, { w: min.x, h: min.y }, { w: max.x, h: max.y });
-    return { ...s, points: rect(n.x, n.y, n.w, n.h).map(r2) };
+    const g = liftGeom(s, f);
+    if (!g.yaw) {
+      const min = gridShares(LIFT_MIN_M, f);
+      const max = gridShares(LIFT_MAX_M, f);
+      const n = resizeBox(b, handle, p, { w: min.x, h: min.y }, { w: max.x, h: max.y });
+      return { ...s, points: rect(n.x, n.y, n.w, n.h).map((q) => rs(q, f)) };
+    }
+    // In the shaft's own frame (metres, centre at 0): resize, then turn the new centre back.
+    const q = inM(p, f);
+    const l = rotS({ x: q.x - g.c.x, y: q.y - g.c.y }, g.yaw);
+    const n = resizeBox({ x: -g.w / 2, y: -g.d / 2, w: g.w, h: g.d }, handle, l, { w: LIFT_MIN_M, h: LIFT_MIN_M }, { w: LIFT_MAX_M, h: LIFT_MAX_M }, { lo: -Infinity, hi: Infinity });
+    const lc = rotS({ x: n.x + n.w / 2, y: n.y + n.h / 2 }, -g.yaw);
+    const c = inShare({ x: g.c.x + lc.x, y: g.c.y + lc.y }, f);
+    const sz = inShare({ x: n.w, y: n.h }, f);
+    return { ...s, points: rect(c.x - sz.x / 2, c.y - sz.y / 2, sz.x, sz.y).map((q) => rs(q, f)) };
   }
   if (s.kind !== "zone") return s;
-  const min = gridShares(ZONE_MIN_M);
+  const min = gridShares(ZONE_MIN_M, f);
   const n = resizeBox(b, handle, p, { w: min.x, h: min.y });
   return {
     ...s,
-    points: s.points.map((q) => r2({ x: n.x + (b.w ? ((q.x - b.x) / b.w) * n.w : 0), y: n.y + (b.h ? ((q.y - b.y) / b.h) * n.h : 0) })),
+    points: s.points.map((q) => rs({ x: n.x + (b.w ? ((q.x - b.x) / b.w) * n.w : 0), y: n.y + (b.h ? ((q.y - b.y) / b.h) * n.h : 0) }, f)),
   };
 }
 
-/** Drag one corner of a zone or one end of a wall / door. A wall or door never gets shorter than 0.1 m. */
-export function moveVertex(s: TEditorShape, index: number, p: { x: number; y: number }): TEditorShape {
+/** Drag one corner of a zone or one end of a wall / door / measurement. A line never gets shorter than 0.1 m. */
+export function moveVertex(s: TEditorShape, index: number, p: { x: number; y: number }, f: TSize = DEFAULT_FRAME): TEditorShape {
   if (!s.points[index]) return s;
-  const points = s.points.map((q, i) => (i === index ? r2({ x: clamp100(p.x), y: clamp100(p.y) }) : q));
-  if (s.kind === "wall" || s.kind === "door") {
-    const [a, b] = points.map(inM);
+  const points = s.points.map((q, i) => (i === index ? rs({ x: clamp100(p.x), y: clamp100(p.y) }, f) : q));
+  if (s.kind === "wall" || s.kind === "door" || s.kind === "measure") {
+    const [a, b] = points.map((t) => inM(t, f));
     if (Math.hypot(b!.x - a!.x, b!.y - a!.y) < MIN_WALL_M) return s;
   }
   return { ...s, points };
 }
 
 /** Shifted back inside the plan if a turn pushed it over an edge. */
-function keepInside(s: TEditorShape): TEditorShape {
-  const b = shapeBox(s);
+function keepInside(s: TEditorShape, f: TSize = DEFAULT_FRAME): TEditorShape {
+  const b = s.kind === "lift" ? shapeBox({ ...s, points: liftCorners(s, f) }) : shapeBox(s);
   const dx = b.x < 0 ? -b.x : b.x + b.w > 100 ? 100 - (b.x + b.w) : 0;
   const dy = b.y < 0 ? -b.y : b.y + b.h > 100 ? 100 - (b.y + b.h) : 0;
-  return dx || dy ? { ...s, points: s.points.map((q) => r2({ x: q.x + dx, y: q.y + dy })) } : s;
+  return dx || dy ? { ...s, points: s.points.map((q) => rs({ x: q.x + dx, y: q.y + dy }, f)) } : s;
 }
 
 /**
- * Turn a door (any angle, round its middle) or a lift shaft (quarter turns
- * round its centre - width and depth swap). The building map stores a lift
- * shaft as width x depth with no angle, so a shaft only turns in 90 degree
- * steps. Other shapes do not turn.
- * ponytail: quarter turns only until the map stores a lift angle (spec batch 2).
+ * Turn a door (any angle, round its middle) or a lift shaft (any angle round
+ * its centre - the map keeps the shaft's angle). `deg` is on screen,
+ * clockwise positive. Other shapes do not turn.
  */
-export function rotateShape(s: TEditorShape, deg: number): TEditorShape {
-  const c = inM(turnCentre(s));
+export function rotateShape(s: TEditorShape, deg: number, f: TSize = DEFAULT_FRAME): TEditorShape {
+  const c = inM(turnCentre(s), f);
   if (s.kind === "door") {
-    const rad = (deg * Math.PI) / 180;
-    const cos = Math.cos(rad);
-    const sin = Math.sin(rad);
+    const rad = deg * DEG;
     const points = s.points.map((q) => {
-      const m = inM(q);
-      return r2(inShare({ x: c.x + (m.x - c.x) * cos - (m.y - c.y) * sin, y: c.y + (m.x - c.x) * sin + (m.y - c.y) * cos }));
+      const m = inM(q, f);
+      const r = rotS({ x: m.x - c.x, y: m.y - c.y }, rad);
+      return rs(inShare({ x: c.x + r.x, y: c.y + r.y }, f), f);
     });
-    return keepInside({ ...s, points });
+    return keepInside({ ...s, points }, f);
   }
   if (s.kind !== "lift") return s;
-  const quarter = ((Math.round(deg / 90) % 4) + 4) % 4;
-  if (quarter % 2 === 0) return s;
-  const b = shapeBox(s);
-  const w = (b.h * MY) / MX;
-  const h = (b.w * MX) / MY;
-  const ctr = turnCentre(s);
-  return keepInside({ ...s, points: rect(ctr.x - w / 2, ctr.y - h / 2, w, h).map(r2) });
+  const yaw = wrapRad(Number(s.meta?.yawRad ?? 0) - deg * DEG);
+  return keepInside({ ...s, meta: { ...(s.meta ?? {}), yawRad: yaw } }, f);
 }
 
-/** The angle (degrees, in real metres) from `c` to `p`. */
-export function angleAt(c: { x: number; y: number }, p: { x: number; y: number }): number {
-  const a = inM(c);
-  const b = inM(p);
+/** The angle (degrees, in real metres, on screen) from `c` to `p`. */
+export function angleAt(c: { x: number; y: number }, p: { x: number; y: number }, f: TSize = DEFAULT_FRAME): number {
+  const a = inM(c, f);
+  const b = inM(p, f);
   return (Math.atan2(b.y - a.y, b.x - a.x) * 180) / Math.PI;
 }
 
-/** A door's swing flipped: its two ends swap, so the hinge moves to the other end and it opens to the other side. */
-export const flipDoor = (s: TEditorShape): TEditorShape => (s.kind === "door" ? { ...s, points: [s.points[1]!, s.points[0]!] } : s);
+/** A door's swing flipped: it opens to the other side (Open-RMF motion_direction), hinge unchanged. */
+export const flipDoor = (s: TEditorShape): TEditorShape =>
+  s.kind === "door" ? { ...s, meta: { ...(s.meta ?? {}), motionDirection: Number(s.meta?.motionDirection ?? 1) < 0 ? 1 : -1 } } : s;
+
+/**
+ * A door's drawing, as Open-RMF's traffic-editor draws it (level.cpp
+ * draw_door): a swing door's leaf and arc from its hinge (the start, or the
+ * end with motion_axis "end") through `motion_degrees` in `motion_direction`;
+ * a double swing door's two leaves split by `right_left_ratio`; a sliding
+ * door's panel(s) and the way they slide. Polylines in shares.
+ */
+export function doorGlyph(s: TEditorShape, f: TSize = DEFAULT_FRAME): Array<Array<{ x: number; y: number }>> {
+  if (s.kind !== "door" || s.points.length < 2) return [];
+  // World metres (y up) so the angles mean what they mean in the building file.
+  const [a, b] = s.points.map((t) => {
+    const m = inM(t, f);
+    return { x: m.x, y: -m.y };
+  });
+  const back = (p: { x: number; y: number }) => r2(inShare({ x: p.x, y: -p.y }, f));
+  const len = Math.hypot(b!.x - a!.x, b!.y - a!.y);
+  if (!len) return [];
+  const ang = Math.atan2(b!.y - a!.y, b!.x - a!.x);
+  const type = String(s.meta?.type ?? "hinged");
+  const dir = Number(s.meta?.motionDirection ?? 1) < 0 ? -1 : 1;
+  const deg = Math.abs(Number(s.meta?.motionDegrees ?? 90)) * DEG;
+  const ratio = Number(s.meta?.rightLeftRatio ?? 1) > 0 ? Number(s.meta?.rightLeftRatio ?? 1) : 1;
+  const swing = (h: { x: number; y: number }, r: number, a0: number, a1: number) => {
+    const at = (t: number) => back({ x: h.x + Math.cos(t) * r, y: h.y + Math.sin(t) * r });
+    return [back(h), ...Array.from({ length: 9 }, (_, i) => at(a0 + ((a1 - a0) * i) / 8)), back(h)];
+  };
+  if (type === "hinged") {
+    const end = s.meta?.motionAxis === "end";
+    const a0 = ang + (end ? Math.PI : 0);
+    return [swing(end ? b! : a!, len, a0, a0 + dir * deg)];
+  }
+  if (type === "double_hinged") {
+    return [swing(a!, (ratio / (1 + ratio)) * len, ang, ang + dir * deg), swing(b!, (1 / (1 + ratio)) * len, ang + Math.PI, ang + Math.PI - dir * deg)];
+  }
+  // Sliding: each panel drawn 0.15 m off the wall line, beside the opening it slides over.
+  const n = { x: -Math.sin(ang) * 0.15 * dir, y: Math.cos(ang) * 0.15 * dir };
+  const u = { x: Math.cos(ang), y: Math.sin(ang) };
+  const off = (p: { x: number; y: number }, k: number) => ({ x: p.x + n.x + u.x * k, y: p.y + n.y + u.y * k });
+  if (type === "double_sliding") {
+    const m = { x: (a!.x + b!.x) / 2, y: (a!.y + b!.y) / 2 };
+    return [
+      [back(off(a!, -len / 2)), back(off(m, -len / 2))],
+      [back(off(m, len / 2)), back(off(b!, len / 2))],
+    ];
+  }
+  return [[back(off(a!, -len)), back(off(a!, 0))]];
+}
+
+/** A single swing door's leaf and quarter arc (shares), for the plain door drawing; null for other kinds. */
+export function doorSwing(s: TEditorShape, f: TSize = DEFAULT_FRAME): { leaf: Array<{ x: number; y: number }>; arc: Array<{ x: number; y: number }> } | null {
+  const type = String(s.meta?.type ?? "hinged");
+  if (s.kind !== "door" || type !== "hinged" || s.points.length < 2) return null;
+  const g = doorGlyph(s, f)[0];
+  if (!g) return null;
+  const arc = g.slice(1, -1);
+  return { leaf: [g[0]!, arc[arc.length - 1]!], arc };
+}
 
 /** A new zone corner at the point, on the edge nearest it (and its index) - or null when the zone is full or no edge is within `withinM`. */
-export function addVertex(s: TEditorShape, p: { x: number; y: number }, withinM = Infinity): { shape: TEditorShape; index: number } | null {
+export function addVertex(s: TEditorShape, p: { x: number; y: number }, withinM = Infinity, f: TSize = DEFAULT_FRAME): { shape: TEditorShape; index: number } | null {
   if (s.kind !== "zone" || s.points.length >= MAX_ZONE_POINTS) return null;
-  const q = inM(p);
-  const pts = s.points.map(inM);
+  const q = inM(p, f);
+  const pts = s.points.map((t) => inM(t, f));
   let best = 0;
   let bestD = Infinity;
   pts.forEach((a, i) => {
@@ -549,7 +761,7 @@ export function addVertex(s: TEditorShape, p: { x: number; y: number }, withinM
   });
   if (bestD > withinM) return null;
   const points = [...s.points];
-  points.splice(best + 1, 0, r2({ x: clamp100(p.x), y: clamp100(p.y) }));
+  points.splice(best + 1, 0, rs({ x: clamp100(p.x), y: clamp100(p.y) }, f));
   return { shape: { ...s, points }, index: best + 1 };
 }
 
@@ -559,9 +771,49 @@ export function removeVertex(s: TEditorShape, index: number): TEditorShape | nul
   return { ...s, points: s.points.filter((_, i) => i !== index) };
 }
 
-/** The listed shapes moved together by (dx, dy) shares, stopping at the plan's edge as a group. */
-export function translateShapes(shapes: TEditorShape[], ids: string[], dx: number, dy: number): TEditorShape[] {
-  const moving = shapes.filter((s) => ids.includes(s.id));
+/**
+ * Lanes follow their waypoints: each lane's two points are copied from its
+ * `meta.from` / `meta.to` waypoints; a lane whose waypoint is gone (or on
+ * another floor) is dropped. Returns the same array when nothing changed.
+ */
+export function syncLanes(shapes: TEditorShape[]): TEditorShape[] {
+  const byId = new Map(shapes.map((s) => [s.id, s]));
+  let changed = false;
+  const out: TEditorShape[] = [];
+  for (const s of shapes) {
+    if (s.kind !== "lane") {
+      out.push(s);
+      continue;
+    }
+    const a = byId.get(String(s.meta?.from));
+    const b = byId.get(String(s.meta?.to));
+    if (!a || !b || a.kind !== "waypoint" || b.kind !== "waypoint" || a.floorNo !== s.floorNo || b.floorNo !== s.floorNo || a === b) {
+      changed = true;
+      continue;
+    }
+    const pa = a.points[0]!;
+    const pb = b.points[0]!;
+    if (s.points[0]?.x === pa.x && s.points[0]?.y === pa.y && s.points[1]?.x === pb.x && s.points[1]?.y === pb.y) out.push(s);
+    else {
+      changed = true;
+      out.push({ ...s, points: [{ ...pa }, { ...pb }] });
+    }
+  }
+  return changed ? out : shapes;
+}
+
+/** What actually moves when `ids` move: a lane moves its two waypoints (and follows them). */
+function movingIds(shapes: TEditorShape[], ids: string[]) {
+  const set = new Set(ids);
+  for (const s of shapes) if (s.kind === "lane" && set.has(s.id)) set.add(String(s.meta?.from)).add(String(s.meta?.to));
+  for (const s of shapes) if (s.kind === "lane") set.delete(s.id);
+  return set;
+}
+
+/** The listed shapes moved together by (dx, dy) shares, stopping at the plan's edge as a group; lanes follow their waypoints. */
+export function translateShapes(shapes: TEditorShape[], ids: string[], dx: number, dy: number, f: TSize = DEFAULT_FRAME): TEditorShape[] {
+  const set = movingIds(shapes, ids);
+  const moving = shapes.filter((s) => set.has(s.id));
   if (!moving.length) return shapes;
   const boxes = moving.map(shapeBox);
   const x0 = Math.min(...boxes.map((b) => b.x));
@@ -571,30 +823,58 @@ export function translateShapes(shapes: TEditorShape[], ids: string[], dx: numbe
   const mx = Math.max(-x0, Math.min(100 - x1, dx));
   const my = Math.max(-y0, Math.min(100 - y1, dy));
   if (!mx && !my) return shapes;
-  return shapes.map((s) => (ids.includes(s.id) ? { ...s, points: s.points.map((q) => r2({ x: q.x + mx, y: q.y + my })) } : s));
+  return syncLanes(shapes.map((s) => (set.has(s.id) ? { ...s, points: s.points.map((q) => rs({ x: q.x + mx, y: q.y + my }, f)) } : s)));
 }
 
-/** A hinged door's swing (shares): the leaf standing open from the hinge (its start) and the quarter arc. Sliding doors have none. */
-export function doorSwing(s: TEditorShape): { leaf: Array<{ x: number; y: number }>; arc: Array<{ x: number; y: number }> } | null {
-  if (s.kind !== "door" || s.meta?.type === "sliding" || s.points.length < 2) return null;
-  const [h, e] = s.points.map(inM);
-  const len = Math.hypot(e!.x - h!.x, e!.y - h!.y);
-  if (!len) return null;
-  const a0 = Math.atan2(e!.y - h!.y, e!.x - h!.x);
-  const at = (a: number) => r2(inShare({ x: h!.x + Math.cos(a) * len, y: h!.y + Math.sin(a) * len }));
-  const arc = Array.from({ length: 9 }, (_, i) => at(a0 - (Math.PI / 2) * (i / 8)));
-  return { leaf: [r2(inShare(h!)), arc[8]!], arc };
+/** The next free fiducial name on a floor: a name used on another floor first (so floors can be lined up), else F1, F2... */
+export function nextFiducialName(shapes: TEditorShape[], floorNo: number): string {
+  const here = new Set(shapes.filter((s) => s.kind === "fiducial" && s.floorNo === floorNo).map((s) => s.name));
+  const elsewhere = shapes.filter((s) => s.kind === "fiducial" && s.floorNo !== floorNo && s.name && !here.has(s.name)).map((s) => s.name!);
+  if (elsewhere.length) return elsewhere[0]!;
+  for (let i = 1; ; i++) if (!here.has(`F${i}`)) return `F${i}`;
 }
 
+/**
+ * Every shape re-expressed in a new frame: each keeps its place in the
+ * building (world metres), so growing the drawing area never moves anything.
+ */
+export function reframeShapes(shapes: TEditorShape[], from: TFrame, to: TFrame): TEditorShape[] {
+  const map = (p: { x: number; y: number }) => {
+    const wx = from.minX + (p.x / 100) * from.w;
+    const wy = from.maxY - (p.y / 100) * from.h;
+    return rs({ x: ((wx - to.minX) / to.w) * 100, y: ((to.maxY - wy) / to.h) * 100 }, to);
+  };
+  return shapes.map((s) => ({ ...s, points: s.points.map(map) }));
+}
+
+/** A point in shares of `f` as world metres (y up), and back. */
+export const shareToWorld = (f: TFrame, p: { x: number; y: number }) => ({ x: f.minX + (p.x / 100) * f.w, y: f.maxY - (p.y / 100) * f.h });
+export const worldToShare = (f: TFrame, p: { x: number; y: number }) => ({ x: ((p.x - f.minX) / f.w) * 100, y: ((f.maxY - p.y) / f.h) * 100 });
+
 /* ---- the reducer ---- */
 
 const sameLayout = (a: TEditorShape[], b: TEditorShape[]) => a === b || JSON.stringify(a) === JSON.stringify(b);
 const keepSelected = (ids: string[], shapes: TEditorShape[]) => ids.filter((id) => shapes.some((s) => s.id === id));
+const snapshot = (s: TEditorState): TSnapshot => ({ shapes: s.shapes, frame: s.frame, graphs: s.graphs, plans: s.plans });
 
-function commit(state: TEditorState, shapes: TEditorShape[]): TEditorState {
+function commit(state: TEditorState, shapes: TEditorShape[], extra: Partial<TEditorState> = {}): TEditorState {
   const undo = [...state.undo];
-  pushUndo(undo, state.shapes);
-  return { ...state, shapes, undo, redo: [], selected: keepSelected(state.selected, shapes), vertex: null, drag: null, notice: null, dirty: true };
+  pushUndo(undo, snapshot(state));
+  const next = syncLanes(shapes);
+  return {
+    ...state,
+    ...extra,
+    shapes: next,
+    undo,
+    redo: [],
+    selected: keepSelected(extra.selected ?? state.selected, next),
+    vertex: null,
+    drag: null,
+    notice: null,
+    dirty: true,
+    lastEdit: null,
+    laneFrom: extra.laneFrom !== undefined ? extra.laneFrom : state.laneFrom && next.some((s) => s.id === state.laneFrom) ? state.laneFrom : null,
+  };
 }
 
 /** The layout a drag gives, worked out from where it started - so snapping never drifts and one drag is one step. */
@@ -602,28 +882,38 @@ function dragShapes(state: TEditorState, x: number, y: number, gridM: number, to
   const d = state.drag!;
   const base = d.base;
   const op = d.op;
+  const f = state.frame;
   if (op.kind === "move") {
-    const first = base.find((s) => state.selected.includes(s.id));
+    const ids = movingIds(base, state.selected);
+    const first = base.find((s) => ids.has(s.id));
     if (!first) return base;
     const ref = first.points[0]!;
     const raw = { x: ref.x + x - d.x, y: ref.y + y - d.y };
-    const to = gridM > 0 ? snapToGrid(raw, gridM) : raw;
-    return translateShapes(base, state.selected, to.x - ref.x, to.y - ref.y);
+    const to = gridM > 0 ? snapToGrid(raw, gridM, f) : raw;
+    return translateShapes(base, state.selected, to.x - ref.x, to.y - ref.y, f);
   }
   const target = base.find((s) => s.id === op.id);
   if (!target) return base;
   let next: TEditorShape;
-  if (op.kind === "handle") next = resizeShape(target, op.handle, snapToGrid({ x, y }, gridM));
+  if (op.kind === "handle") next = resizeShape(target, op.handle, target.kind === "lift" && target.meta?.yawRad ? { x, y } : snapToGrid({ x, y }, gridM, f), f);
   else if (op.kind === "vertex") {
-    const ends = shapesOnFloor(base, target.floorNo).filter((s) => s.id !== target.id).flatMap((s) => s.points);
-    next = moveVertex(target, op.index, snapPoint({ x, y }, gridM, ends, toleranceM));
+    const ends = shapesOnFloor(base, target.floorNo).filter((s) => s.id !== target.id && s.kind !== "lane").flatMap((s) => s.points);
+    next = moveVertex(target, op.index, snapPoint({ x, y }, gridM, ends, toleranceM, f), f);
   } else {
     const c = turnCentre(target);
-    let deg = angleAt(c, { x, y }) - angleAt(c, { x: d.x, y: d.y });
-    if (target.kind === "door" && gridM > 0) deg = Math.round(deg / ROTATE_SNAP_DEG) * ROTATE_SNAP_DEG;
-    next = rotateShape(target, deg);
+    let deg = angleAt(c, { x, y }, f) - angleAt(c, { x: d.x, y: d.y }, f);
+    if (gridM > 0) {
+      if (target.kind === "door") deg = Math.round(deg / ROTATE_SNAP_DEG) * ROTATE_SNAP_DEG;
+      else if (target.kind === "lift") {
+        // Snap the shaft's resulting angle (not the sweep) to 15 degrees.
+        const start = Number(target.meta?.yawRad ?? 0) / DEG;
+        const end = Math.round((start - deg) / ROTATE_SNAP_DEG) * ROTATE_SNAP_DEG;
+        deg = start - end;
+      }
+    }
+    next = rotateShape(target, deg, f);
   }
-  return base.map((s) => (s.id === target.id ? next : s));
+  return syncLanes(base.map((s) => (s.id === target.id ? next : s)));
 }
 
 const TOO_FEW_CORNERS = "A zone needs at least three corners - this one can't lose another.";
@@ -631,35 +921,76 @@ const TOO_FEW_CORNERS = "A zone needs at least three corners - this one can't lo
 let seq = 0;
 const nextId = () => `sh${Date.now().toString(36)}${(seq++).toString(36)}`;
 
+/** Every point of every shape moved by a world transform (rotate, scale, then shift - Open-RMF transform.py order). */
+function transformPoints(shapes: TEditorShape[], ids: Set<string>, f: TFrame, t: { scale: number; rot: number; tx: number; ty: number }) {
+  return shapes.map((s) => {
+    if (!ids.has(s.id)) return s;
+    const points = s.points.map((p) => {
+      const w = shareToWorld(f, p);
+      const q = { x: (w.x * Math.cos(t.rot) - w.y * Math.sin(t.rot)) * t.scale + t.tx, y: (w.x * Math.sin(t.rot) + w.y * Math.cos(t.rot)) * t.scale + t.ty };
+      const sh = worldToShare(f, q);
+      return rs({ x: clamp100(sh.x), y: clamp100(sh.y) }, f);
+    });
+    return { ...s, points };
+  });
+}
+
+/** The drawing in a new frame (world positions kept); undo / redo snapshots are moved too, so they stay consistent. */
+function reframeState(state: TEditorState, to: TFrame): TEditorState {
+  const from = state.frame;
+  if (to.minX === from.minX && to.maxY === from.maxY && to.w === from.w && to.h === from.h) return state;
+  if (!(to.w > 0 && to.h > 0)) return state;
+  const restack = (stack: string[]) =>
+    stack.map((raw) => {
+      const snap = JSON.parse(raw) as TSnapshot | TEditorShape[];
+      return Array.isArray(snap) ? raw : JSON.stringify({ ...snap, shapes: reframeShapes(snap.shapes, snap.frame, to), frame: to });
+    });
+  return {
+    ...state,
+    shapes: reframeShapes(state.shapes, from, to),
+    frame: { ...to },
+    undo: restack(state.undo),
+    redo: restack(state.redo),
+    measureFrom: null,
+    dirty: true,
+  };
+}
+
 export function editorReduce(state: TEditorState, action: TEditorAction): TEditorState {
   switch (action.type) {
     case "load":
-      return emptyEditor(action.shapes);
+      return emptyEditor(action.shapes, { frame: state.frame, graphs: state.graphs });
+    case "loadAll":
+      return { ...emptyEditor(action.shapes, { frame: action.frame, graphs: action.graphs }), notice: action.notice ?? null, dirty: action.dirty ?? false };
     case "tool":
       // Move keeps the selection (place, then adjust); a drawing tool starts clean.
-      return { ...state, selected: action.tool === "move" ? state.selected : [], vertex: null, notice: null };
+      return { ...state, selected: action.tool === "move" ? state.selected : [], vertex: null, notice: null, laneFrom: null, measureFrom: null };
     case "notice":
       return { ...state, notice: { text: action.text, ok: action.ok } };
     case "saved":
-      return { ...state, undo: [], redo: [], drag: null, dirty: false, notice: { text: action.text, ok: true } };
+      return { ...state, undo: [], redo: [], drag: null, dirty: false, plans: {}, lastEdit: null, notice: { text: action.text, ok: true } };
     case "undo":
     case "redo": {
       const isUndo = action.type === "undo";
       const from = [...(isUndo ? state.undo : state.redo)];
       if (!from.length) return { ...state, notice: { text: isUndo ? "Nothing to undo." : "Nothing to redo.", ok: false } };
       const to = [...(isUndo ? state.redo : state.undo)];
-      const shapes = popUndo<TEditorShape[]>(from) ?? state.shapes;
-      pushUndo(to, state.shapes);
+      const raw = popUndo<TSnapshot | TEditorShape[]>(from);
+      const snap: TSnapshot = Array.isArray(raw) ? { ...snapshot(state), shapes: raw } : raw ?? snapshot(state);
+      pushUndo(to, snapshot(state));
       return {
         ...state,
-        shapes,
+        ...snap,
         undo: isUndo ? from : to,
         redo: isUndo ? to : from,
-        selected: keepSelected(state.selected, shapes),
+        selected: keepSelected(state.selected, snap.shapes),
         vertex: null,
         drag: null,
         notice: null,
         dirty: true,
+        lastEdit: null,
+        laneFrom: null,
+        measureFrom: null,
       };
     }
     case "rename": {
@@ -676,7 +1007,7 @@ export function editorReduce(state: TEditorState, action: TEditorAction): TEdito
         if (i >= 0 && mode === "toggle") sel.splice(i, 1);
         else if (i < 0) sel.push(id);
       }
-      return { ...state, selected: keepSelected(sel, state.shapes), vertex: null, notice: null };
+      return { ...state, selected: keepSelected(sel, state.shapes), vertex: null, notice: null, lastEdit: null };
     }
     case "selectAll":
       return { ...state, selected: shapesOnFloor(state.shapes, action.floorNo).map((s) => s.id), vertex: null };
@@ -693,14 +1024,14 @@ export function editorReduce(state: TEditorState, action: TEditorAction): TEdito
       const base = state.drag.base;
       if (sameLayout(base, state.shapes)) return { ...state, drag: null };
       const undo = [...state.undo];
-      pushUndo(undo, base);
-      return { ...state, undo, redo: [], drag: null, dirty: true };
+      pushUndo(undo, { ...snapshot(state), shapes: base });
+      return { ...state, undo, redo: [], drag: null, dirty: true, lastEdit: null };
     }
     case "dragCancel":
       return state.drag ? { ...state, shapes: state.drag.base, drag: null } : state;
     case "nudge": {
       if (!state.selected.length) return state;
-      const shapes = translateShapes(state.shapes, state.selected, action.dx / MX, action.dy / MY);
+      const shapes = translateShapes(state.shapes, state.selected, (action.dx / state.frame.w) * 100, (action.dy / state.frame.h) * 100, state.frame);
       return shapes === state.shapes ? state : commit(state, shapes);
     }
     case "remove": {
@@ -719,11 +1050,11 @@ export function editorReduce(state: TEditorState, action: TEditorAction): TEdito
       const kinds: TShapeKind[] = action.type === "flip" ? ["door"] : ["door", "lift"];
       const targets = new Set(state.shapes.filter((s) => state.selected.includes(s.id) && kinds.includes(s.kind)).map((s) => s.id));
       if (!targets.size) return state;
-      return commit(state, state.shapes.map((s) => (targets.has(s.id) ? (action.type === "flip" ? flipDoor(s) : rotateShape(s, 90)) : s)));
+      return commit(state, state.shapes.map((s) => (targets.has(s.id) ? (action.type === "flip" ? flipDoor(s) : rotateShape(s, 90, state.frame)) : s)));
     }
     case "addVertex": {
       const zone = state.shapes.find((s) => s.id === action.id);
-      const added = zone ? addVertex(zone, { x: action.x, y: action.y }, action.within) : null;
+      const added = zone ? addVertex(zone, { x: action.x, y: action.y }, action.within, state.frame) : null;
       if (!added) return state;
       return { ...commit(state, state.shapes.map((s) => (s.id === action.id ? added.shape : s))), selected: [action.id], vertex: { id: action.id, index: added.index } };
     }
@@ -745,14 +1076,115 @@ export function editorReduce(state: TEditorState, action: TEditorAction): TEdito
       return state;
     }
     case "place": {
-      if (action.tool === "move" || action.tool === "delete") return state;
-      const shape = newShape(action.tool, action.id ?? nextId(), action.floorNo, action.x, action.y, {
-        name: action.zoneName,
-        floors: action.floors,
-      });
+      if (["move", "delete", "lane", "measure"].includes(action.tool)) return state;
+      const kind = action.tool as TShapeKind;
+      const name = kind === "fiducial" ? action.name ?? nextFiducialName(state.shapes, action.floorNo) : kind === "zone" ? action.zoneName : action.name;
+      const shape = newShape(kind, action.id ?? nextId(), action.floorNo, action.x, action.y, { name, floors: action.floors }, state.frame);
+      if (kind === "waypoint") shape.meta = { params: {} };
       // The new shape comes selected, so its handles are there to size it straight away.
       return { ...commit(state, [...state.shapes, shape]), selected: [shape.id], vertex: null };
     }
+    case "laneClick": {
+      const hit = action.hitId ? state.shapes.find((s) => s.id === action.hitId && s.kind === "waypoint" && s.floorNo === action.floorNo) : undefined;
+      // A click on the waypoint the chain is at ends the chain.
+      if (hit && hit.id === state.laneFrom) return { ...state, laneFrom: null, notice: null };
+      let shapes = state.shapes;
+      let at = hit;
+      if (!at) {
+        at = newShape("waypoint", action.id ?? nextId(), action.floorNo, action.x, action.y, {}, state.frame);
+        at.meta = { params: {} };
+        shapes = [...shapes, at];
+      }
+      const from = state.laneFrom ? state.shapes.find((s) => s.id === state.laneFrom) : undefined;
+      if (!from || from.floorNo !== action.floorNo) {
+        if (shapes === state.shapes) return { ...state, laneFrom: at.id, selected: [at.id], notice: null };
+        return { ...commit(state, shapes), laneFrom: at.id, selected: [at.id] };
+      }
+      const exists = state.shapes.some(
+        (s) =>
+          s.kind === "lane" &&
+          Number(s.meta?.graphIdx ?? 0) === action.graphIdx &&
+          ((s.meta?.from === from.id && s.meta?.to === at!.id) || (s.meta?.from === at!.id && s.meta?.to === from.id)),
+      );
+      if (exists) return { ...state, laneFrom: at.id, notice: { text: "There is already a lane between these two waypoints on this route graph.", ok: false } };
+      const lane: TEditorShape = {
+        id: action.laneId ?? nextId(),
+        kind: "lane",
+        floorNo: action.floorNo,
+        points: [{ ...from.points[0]! }, { ...at.points[0]! }],
+        meta: { from: from.id, to: at.id, graphIdx: action.graphIdx, bidirectional: true },
+      };
+      const graphs = state.graphs.some((g) => g.idx === action.graphIdx)
+        ? state.graphs
+        : [...state.graphs, { idx: action.graphIdx, name: `Graph ${action.graphIdx}`, brands: [] }].sort((x, y) => x.idx - y.idx);
+      return { ...commit(state, [...shapes, lane], { graphs }), laneFrom: at.id, selected: [lane.id] };
+    }
+    case "laneEnd":
+      return state.laneFrom ? { ...state, laneFrom: null } : state;
+    case "measureClick": {
+      const p = rs({ x: clamp100(action.x), y: clamp100(action.y) }, state.frame);
+      if (!state.measureFrom) return { ...state, measureFrom: p, notice: null };
+      const a = state.measureFrom;
+      const f = state.frame;
+      const len = Math.hypot(((p.x - a.x) / 100) * f.w, ((p.y - a.y) / 100) * f.h);
+      if (len < 0.05) return { ...state, measureFrom: null, notice: { text: "Pick two points further apart.", ok: false } };
+      const shape: TEditorShape = { id: action.id ?? nextId(), kind: "measure", floorNo: action.floorNo, points: [a, p], meta: { distanceM: Math.round(len * 100) / 100 } };
+      return { ...commit(state, [...state.shapes, shape]), measureFrom: null, selected: [shape.id] };
+    }
+    case "setProps": {
+      const target = state.shapes.find((s) => s.id === action.id);
+      if (!target) return state;
+      const next: TEditorShape = {
+        ...target,
+        ...(action.name !== undefined ? { name: action.name } : {}),
+        ...(action.floors !== undefined ? { floors: [...new Set(action.floors)].sort((a, b) => a - b) } : {}),
+        ...(action.meta ? { meta: { ...(target.meta ?? {}), ...action.meta } } : {}),
+      };
+      const shapes = state.shapes.map((s) => (s.id === target.id ? next : s));
+      const key = action.field ? `${target.id}:${action.field}` : null;
+      // Typing into the same field again is part of the same step.
+      if (key && key === state.lastEdit) return { ...state, shapes: syncLanes(shapes), dirty: true };
+      return { ...commit(state, shapes), lastEdit: key };
+    }
+    case "graphs": {
+      const idx = new Set(action.graphs.map((g) => g.idx));
+      // A removed graph takes its lanes with it.
+      const shapes = state.shapes.filter((s) => s.kind !== "lane" || idx.has(Number(s.meta?.graphIdx ?? 0)));
+      return commit(state, shapes, { graphs: [...action.graphs].sort((a, b) => a.idx - b.idx) });
+    }
+    case "setShapes":
+      return { ...commit(state, action.shapes, action.graphs ? { graphs: [...action.graphs].sort((a, b) => a.idx - b.idx) } : {}), notice: action.notice ?? null };
+    case "reframe": {
+      const next = reframeState(state, action.frame);
+      return action.auto && next !== state ? { ...next, dirty: state.dirty } : next;
+    }
+    case "plan":
+      return commit(state, state.shapes, { plans: { ...state.plans, [String(action.floorNo)]: action.placement } });
+    case "transformFloor": {
+      const ids = new Set(state.shapes.filter((s) => s.floorNo === action.floorNo && s.kind !== "lift").map((s) => s.id));
+      // Grow the drawing area first if the moved floor would leave it, so nothing is squashed against the edge.
+      const t = action.t;
+      const f0 = state.frame;
+      const moved = state.shapes
+        .filter((s) => ids.has(s.id))
+        .flatMap((s) => s.points)
+        .map((p) => {
+          const w = shareToWorld(f0, p);
+          return { x: (w.x * Math.cos(t.rot) - w.y * Math.sin(t.rot)) * t.scale + t.tx, y: (w.x * Math.sin(t.rot) + w.y * Math.cos(t.rot)) * t.scale + t.ty };
+        });
+      let base = state;
+      if (moved.length) {
+        const minX = Math.min(f0.minX, ...moved.map((q) => q.x - 1));
+        const maxX = Math.max(f0.minX + f0.w, ...moved.map((q) => q.x + 1));
+        const minY = Math.min(f0.maxY - f0.h, ...moved.map((q) => q.y - 1));
+        const maxY = Math.max(f0.maxY, ...moved.map((q) => q.y + 1));
+        const grown = { minX: round2(minX), maxY: round2(maxY), w: round2(maxX - minX), h: round2(maxY - minY) };
+        if (grown.minX !== f0.minX || grown.maxY !== f0.maxY || grown.w !== f0.w || grown.h !== f0.h) base = reframeState(state, grown);
+      }
+      const shapes = transformPoints(base.shapes, ids, base.frame, t);
+      const plans = action.placement ? { ...base.plans, [String(action.floorNo)]: action.placement } : base.plans;
+      return commit(base, shapes, { plans });
+    }
     default:
       return state;
   }
@@ -761,7 +1193,8 @@ export function editorReduce(state: TEditorState, action: TEditorAction): TEdito
 /**
  * Why Save must wait, in plain words - or null. The handoff's sentence for
  * an unnamed zone; then what the API would refuse (a lift on one floor,
- * shapes past its limits).
+ * shapes past its limits, names that must be unique, lanes that lost a
+ * waypoint).
  */
 export function editorProblem(state: TEditorState): string | null {
   const unnamed = state.shapes.find((s) => s.kind === "zone" && !s.name);
@@ -774,16 +1207,104 @@ export function editorProblem(state: TEditorState): string | null {
     const a = shapeAnchor(lonely);
     return `Can't save yet: the lift shaft at (${a.x}, ${a.y}) serves only one floor. A lift needs at least two floors - this building's robots report only ${floorName(lonely.floorNo)}.`;
   }
-  const long = state.shapes.find((s) => s.kind === "zone" && (s.name ?? "").length > 60);
-  if (long) return `Can't save yet: the zone name "${long.name!.slice(0, 20)}…" is too long. Use 60 characters or fewer.`;
+  const long = state.shapes.find((s) => (s.kind === "zone" || s.kind === "waypoint" || s.kind === "fiducial") && (s.name ?? "").length > 60);
+  if (long) return `Can't save yet: the name "${long.name!.slice(0, 20)}…" is too long. Use 60 characters or fewer.`;
+  const routes = routeProblems(state);
+  if (routes.errors.length) return `Can't save yet: ${routes.errors[0]!.text}`;
   if (!state.dirty) return "Nothing to save — the map hasn't changed.";
-  const body = toMapBody(state.shapes, "check");
-  const walls = body.levels.flatMap((l) => (l.walls ?? []).map((w) => ({ floorNo: l.floorNo, ...w })));
-  const zones = body.levels.flatMap((l) => (l.zones ?? []).map((z) => ({ floorNo: l.floorNo, ...z })));
+  // In real metres (whatever the frame), relative to the frame's corner.
+  const m = (p: { x: number; y: number }) => r2(inM(p, state.frame));
+  const walls = state.shapes.filter((s) => s.kind === "wall").map((s) => ({ floorNo: s.floorNo, start: m(s.points[0]!), end: m(s.points[1]!) }));
+  const zones = state.shapes.filter((s) => s.kind === "zone").map((s) => ({ floorNo: s.floorNo, name: s.name ?? "", points: s.points.map(m) }));
   const problem = layoutProblem(walls, zones);
   return problem ? `Can't save yet: ${problem}` : null;
 }
 
+export type TCheck = { text: string; ids: string[] };
+
+function segmentsCross(a: { x: number; y: number }, b: { x: number; y: number }, c: { x: number; y: number }, d: { x: number; y: number }) {
+  const cross = (o: { x: number; y: number }, p: { x: number; y: number }, q: { x: number; y: number }) => (p.x - o.x) * (q.y - o.y) - (p.y - o.y) * (q.x - o.x);
+  const d1 = cross(c, d, a);
+  const d2 = cross(c, d, b);
+  const d3 = cross(a, b, c);
+  const d4 = cross(a, b, d);
+  // Proper crossings only: touching at an end (a lane ending on a wall corner) is not a crossing.
+  return ((d1 > 1e-9 && d2 < -1e-9) || (d1 < -1e-9 && d2 > 1e-9)) && ((d3 > 1e-9 && d4 < -1e-9) || (d3 < -1e-9 && d4 > 1e-9));
+}
+
+/**
+ * The robot-route checks, in plain words, each naming the shapes it is about
+ * (the side panel selects them). Errors stop a save (the fleet software would
+ * refuse them); warnings are shown and can be saved anyway.
+ */
+export function routeProblems(state: Pick<TEditorState, "shapes" | "frame">): { errors: TCheck[]; warnings: TCheck[] } {
+  const errors: TCheck[] = [];
+  const warnings: TCheck[] = [];
+  const f = state.frame;
+  const shapes = state.shapes;
+  const byId = new Map(shapes.map((s) => [s.id, s]));
+  const dupes = (list: TEditorShape[], word: string, scope: string) => {
+    const seen = new Map<string, TEditorShape>();
+    for (const s of list) {
+      const n = (s.name ?? "").trim();
+      if (!n) continue;
+      const other = seen.get(n.toLowerCase());
+      if (other) errors.push({ text: `two ${word} ${scope} are both called "${n}" - give each its own name.`, ids: [other.id, s.id] });
+      else seen.set(n.toLowerCase(), s);
+    }
+  };
+  const floors = [...new Set(shapes.map((s) => s.floorNo))].sort((a, b) => a - b);
+  for (const fl of floors) {
+    dupes(shapes.filter((s) => s.kind === "waypoint" && s.floorNo === fl), "waypoints", `on ${floorName(fl)}`);
+    dupes(shapes.filter((s) => s.kind === "fiducial" && s.floorNo === fl), "fiducials", `on ${floorName(fl)}`);
+  }
+  const doorNames = new Map<string, TEditorShape>();
+  for (const d of shapes.filter((s) => s.kind === "door" && s.meta?.name)) {
+    const n = String(d.meta!.name).trim().toLowerCase();
+    const other = doorNames.get(n);
+    if (other) errors.push({ text: `two doors are both called "${d.meta!.name}" - door names must be unique in the building.`, ids: [other.id, d.id] });
+    else doorNames.set(n, d);
+  }
+  // Lanes that lost a waypoint (a file import can carry them; the editor drops them as they happen).
+  for (const l of shapes.filter((s) => s.kind === "lane")) {
+    const a = byId.get(String(l.meta?.from));
+    const b = byId.get(String(l.meta?.to));
+    if (!a || !b) errors.push({ text: `a lane on ${floorName(l.floorNo)} ends at a waypoint that no longer exists - delete it or draw it again.`, ids: [l.id] });
+    else if (a === b) errors.push({ text: `a lane on ${floorName(l.floorNo)} starts and ends at the same waypoint.`, ids: [l.id] });
+  }
+  // Same name on different floors: allowed, but robots are sent to a waypoint by name.
+  const named = new Map<string, TEditorShape[]>();
+  for (const w of shapes.filter((s) => s.kind === "waypoint" && s.name?.trim())) named.set(w.name!.trim().toLowerCase(), [...(named.get(w.name!.trim().toLowerCase()) ?? []), w]);
+  for (const [, list] of named) {
+    const floorsOf = [...new Set(list.map((w) => w.floorNo))];
+    if (floorsOf.length > 1) warnings.push({ text: `"${list[0]!.name}" is a waypoint name on ${floorsOf.map(floorName).join(" and ")} - robots are sent to a waypoint by its name, so a unique name is safer.`, ids: list.map((w) => w.id) });
+  }
+  for (const w of shapes.filter((s) => s.kind === "waypoint")) {
+    const p = (w.meta?.params ?? {}) as Record<string, unknown>;
+    if (p.is_charger && !String(p.dock_name ?? "").trim()) warnings.push({ text: `the charger ${w.name ? `"${w.name}"` : `on ${floorName(w.floorNo)}`} has no dock name - robots need it to dock there.`, ids: [w.id] });
+    if (p.is_charger && !w.name?.trim()) warnings.push({ text: `a charger on ${floorName(w.floorNo)} has no name - robots are sent to a charger by its name.`, ids: [w.id] });
+    const lanes = shapes.filter((s) => s.kind === "lane" && (s.meta?.from === w.id || s.meta?.to === w.id));
+    if (!lanes.length && (p.is_charger || p.is_parking_spot || p.is_holding_point)) warnings.push({ text: `the waypoint ${w.name ? `"${w.name}"` : `on ${floorName(w.floorNo)}`} is not on any lane, so robots cannot reach it.`, ids: [w.id] });
+  }
+  // A lane through a wall: robots follow lanes, so this is almost always a drawing slip.
+  const m = (p: { x: number; y: number }) => inM(p, f);
+  for (const l of shapes.filter((s) => s.kind === "lane" && s.points.length === 2)) {
+    const [a, b] = l.points.map(m);
+    const wall = shapes.find((s) => s.kind === "wall" && s.floorNo === l.floorNo && s.points.length === 2 && segmentsCross(a!, b!, m(s.points[0]!), m(s.points[1]!)));
+    if (!wall) continue;
+    const door = shapes.some((s) => s.kind === "door" && s.floorNo === l.floorNo && s.points.length === 2 && segmentsCross(a!, b!, m(s.points[0]!), m(s.points[1]!)));
+    if (!door) warnings.push({ text: `a lane on ${floorName(l.floorNo)} crosses a wall with no door in it.`, ids: [l.id, wall.id] });
+  }
+  for (const lift of shapes.filter((s) => s.kind === "lift")) {
+    const levelDoors = (lift.meta?.levelDoors ?? {}) as Record<string, string[]>;
+    const doors = (lift.meta?.doors ?? []) as Array<{ name: string }>;
+    if (!doors.length) continue;
+    const silent = (lift.floors ?? []).filter((fl) => Array.isArray(levelDoors[String(fl)]) && !levelDoors[String(fl)]!.length);
+    if (silent.length) warnings.push({ text: `${lift.meta?.name ?? "A lift"} stops at ${silent.map(floorName).join(", ")} but no cabin door opens there.`, ids: [lift.id] });
+  }
+  return { errors, warnings };
+}
+
 /** "Saved at 14:02 · 5 elements on Tower A." */
 export function savedNotice(at: Date, count: number, siteName: string): string {
   const hh = String(at.getHours()).padStart(2, "0");
@@ -798,6 +1319,7 @@ export function saveErrorText(e: any): string {
   if (status === 409) return "Someone else saved this map after you opened it. Your changes are still here - reload the page to see theirs, then make yours again.";
   if (status === 401) return "Your session has ended. Sign in again, then save - your changes stay on this page until you leave it.";
   if (status === 403 || status === 404) return "You can't change this building's map. Ask a manager with robot set-up rights to save it.";
+  if (status === 413) return "This building is too large to save in one go (2 MB). Remove some floors or points, or split it into two maps.";
   if (typeof msg === "string" && msg.trim()) return `The map was not saved: ${msg.trim()}`;
   return "The map was not saved - the server could not be reached. Your changes are still here; try Save again.";
 }