@agent-os-lab/agent-game-sdk 0.1.9 → 0.1.11

package/src/office/layout/resolver.ts

@@ -2,8 +2,18 @@ import type { AgentGameOfficeAgent, AgentGameOfficeZoneId } from "../core/types"
 import {
   type AgentGameOfficeConfig,
   type AgentGameOfficeRoomType,
+  type NormalizedOfficeConnectorConfig,
+  type NormalizedOfficeFloorConfig,
+  type NormalizedOfficeRoomConfig,
   normalizeOfficeConfig,
 } from "./config";
+import type {
+  NavigationEdge,
+  NavigationNode,
+  ResolvedBuildingNavigationGraph,
+} from "./navigation";
+
+export const FLOOR_ELEVATION_STEP = 20;
 
 const OFFICE_LAYOUT_SCALE = 1.2;
 const OFFICE_FLOOR_CENTER_X = 16;
@@ -18,12 +28,25 @@ const LARGE_MEETING_CHAIR_DISTANCE_Z = 2.55 * OFFICE_LAYOUT_SCALE;
 const ROOMS_PER_ROW = 3;
 const ROOM_ROW_GAP = 0;
 const NORTH_WALL_BOOKCASE_Z_OFFSET = 0.32;
+const ELEVATOR_CORE_MARGIN_X = 3.2;
+const ELEVATOR_CORE_MARGIN_Z = 3.2;
+const ELEVATOR_ENTRY_OFFSET_Z = 1.6;
 
 export type OfficeComponentKind =
   | "desk"
   | "officeChair"
   | "monitor"
   | "meetingTable"
+  | "diningTable"
+  | "cafeCounter"
+  | "cafeTable"
+  | "kitchenCounter"
+  | "kitchenStove"
+  | "kitchenFridge"
+  | "gardenPlanter"
+  | "gardenTree"
+  | "gardenBench"
+  | "gardenPath"
   | "meetingGlassRoom"
   | "largeMeetingTable"
   | "tableCup"
@@ -46,11 +69,15 @@ export type OfficeComponentKind =
   | "dumbbellRack"
   | "weightBench"
   | "yogaMat"
-  | "gymMirror";
+  | "gymMirror"
+  | "elevatorDoor"
+  | "elevatorFrame"
+  | "elevatorIndicator";
 
 export type ResolvedOfficeComponentInstance = {
   id: string;
   kind: OfficeComponentKind;
+  floorId: string;
   roomId: string | null;
   position: { x: number; y?: number; z: number };
   rotation?: number;
@@ -75,6 +102,7 @@ export type ResolvedOfficeComponentInstance = {
 
 export type ResolvedOfficeRoom = {
   id: string;
+  floorId: string;
   type: AgentGameOfficeRoomType;
   bounds: { x: number; z: number; width: number; depth: number };
   capacity: number;
@@ -82,6 +110,7 @@ export type ResolvedOfficeRoom = {
 
 export type ResolvedFloorTile = {
   id: string;
+  floorId: string;
   color: number;
   x: number;
   z: number;
@@ -93,6 +122,7 @@ export type ResolvedWallSide = "north" | "south" | "west" | "east";
 
 export type ResolvedWall = {
   id: string;
+  floorId: string;
   roomId: string;
   side: ResolvedWallSide;
   x: number;
@@ -114,6 +144,7 @@ export type ResolvedLight = {
 export type ResolvedSeatAnchor = {
   id: string;
   roomId: string;
+  floorId: string;
   zoneId: AgentGameOfficeZoneId;
   position: { x: number; z: number };
   facing?: { x: number; z: number };
@@ -125,14 +156,56 @@ export type ResolvedZoneAnchor = ResolvedSeatAnchor;
 export type ResolvedWallAnchor = {
   id: string;
   roomId: string;
+  floorId: string;
   position: { x: number; z: number };
   rotation?: number;
   faceDirection: -1 | 1;
 };
 
+export type ResolvedOffstageAnchor = {
+  id: "offstage";
+  roomId: null;
+  floorId: null;
+  zoneId: "offstage";
+  position: { x: number; y: number; z: number };
+};
+
+export type ResolvedOfficeFloor = {
+  id: string;
+  name: string;
+  level: number;
+  elevation: number;
+  rooms: ResolvedOfficeRoom[];
+  floorTiles: ResolvedFloorTile[];
+  walls: ResolvedWall[];
+  components: ResolvedOfficeComponentInstance[];
+};
+
+export type ResolvedElevatorStop = {
+  floorId: string;
+  entryNodeId: string;
+  cabinNodeId: string;
+  entryPosition: { x: number; y: number; z: number };
+  cabinPosition: { x: number; y: number; z: number };
+};
+
+export type ResolvedBuildingConnector = {
+  id: string;
+  type: "elevator";
+  name: string;
+  serves: string[];
+  stops: ResolvedElevatorStop[];
+};
+
 export type ResolvedOfficeLayout = {
+  building: {
+    floors: ResolvedOfficeFloor[];
+    connectors: ResolvedBuildingConnector[];
+    navigation: ResolvedBuildingNavigationGraph;
+  };
   scene: {
     width: number;
+    height: number;
     depth: number;
     center: { x: number; z: number };
     floorTileSize: number;
@@ -146,7 +219,7 @@ export type ResolvedOfficeLayout = {
     seats: ResolvedSeatAnchor[];
     zones: ResolvedZoneAnchor[];
     wallDecorations: ResolvedWallAnchor[];
-    offstage: ResolvedSeatAnchor;
+    offstage: ResolvedOffstageAnchor;
   };
 };
 
@@ -159,6 +232,15 @@ type MutableResolvedLayout = ResolvedOfficeLayout & {
   };
 };
 
+type FloorResolvedLayout = ResolvedOfficeFloor & {
+  scene: Pick<ResolvedOfficeLayout["scene"], "width" | "depth" | "center" | "floorTileSize">;
+  anchors: {
+    seats: ResolvedSeatAnchor[];
+    zones: ResolvedZoneAnchor[];
+    wallDecorations: ResolvedWallAnchor[];
+  };
+};
+
 const DESK_TEMPLATE = [
   { seat: { x: scaleOfficeX(-12), z: scaleOfficeZ(-6.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-12), z: scaleOfficeZ(-8) } },
   { seat: { x: scaleOfficeX(-7), z: scaleOfficeZ(-6.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-7), z: scaleOfficeZ(-8) } },
@@ -220,13 +302,30 @@ const LOUNGE_CENTER = { x: scaleOfficeX(4.8), z: scaleOfficeZ(8.2) } as const;
 
 export function resolveOfficeLayout(config?: AgentGameOfficeConfig): ResolvedOfficeLayout {
   const normalized = normalizeOfficeConfig(config);
-  const offstage = createAnchor("offstage", "offstage-1", "offstage", "offstage", scaleOfficeX(-13), scaleOfficeZ(8), {
-    x: scaleOfficeX(-13),
-    z: scaleOfficeZ(8),
-  });
+  const floors = normalized.building.floors.map((floor) =>
+    resolveOfficeFloor(floor, floor.level * FLOOR_ELEVATION_STEP, normalized.building.floors.length === 1)
+  );
+  const connectors = resolveBuildingConnectors(normalized.building.connectors, floors);
+  const offstage = createOffstageAnchor();
+  return assembleBuildingLayout(floors, connectors, offstage);
+}
+
+function resolveOfficeFloor(
+  floor: NormalizedOfficeFloorConfig,
+  elevation: number,
+  useLegacyRoomIds: boolean,
+): FloorResolvedLayout {
+  const offstage = createOffstageAnchor();
+  const rooms = floor.rooms.map((room, index) => createRoom(resolveRoomId(room, useLegacyRoomIds), floor.id, room.type, room.capacity, index));
   const layout: MutableResolvedLayout = {
+    building: {
+      floors: [],
+      connectors: [],
+      navigation: { nodes: [], edges: [] },
+    },
     scene: {
       width: OFFICE_FLOOR_WIDTH,
+      height: 0,
       depth: OFFICE_FLOOR_DEPTH,
       center: { x: OFFICE_FLOOR_CENTER_X, z: 0 },
       floorTileSize: OFFICE_FLOOR_TILE_SIZE,
@@ -237,7 +336,7 @@ export function resolveOfficeLayout(config?: AgentGameOfficeConfig): ResolvedOff
         { id: "directional", kind: "directional", color: 0xffffff, intensity: 1.2, position: { x: 10, y: 18, z: 8 } },
       ],
     },
-    rooms: normalized.rooms.map((room, index) => createRoom(room.id, room.type, room.capacity, index)),
+    rooms,
     components: [],
     anchors: {
       seats: [],
@@ -252,21 +351,320 @@ export function resolveOfficeLayout(config?: AgentGameOfficeConfig): ResolvedOff
       addOfficePreset(layout, room);
     } else if (room.type === "auditorium") {
       addAuditoriumPreset(layout, room);
-    } else {
+    } else if (room.type === "gym") {
       addGymPreset(layout, room);
+    } else if (room.type === "dining") {
+      addDiningPreset(layout, room);
+    } else if (room.type === "cafe") {
+      addCafePreset(layout, room);
+    } else {
+      addSkyGardenPreset(layout, room);
     }
   }
 
   applyAdaptiveSceneBounds(layout);
-  layout.anchors.seats.push(offstage);
-  layout.anchors.zones.push(offstage);
-  return layout;
+  return {
+    id: floor.id,
+    name: floor.name,
+    level: floor.level,
+    elevation,
+    rooms: layout.rooms,
+    floorTiles: layout.scene.floorTiles,
+    walls: layout.scene.walls,
+    components: layout.components,
+    scene: {
+      width: layout.scene.width,
+      depth: layout.scene.depth,
+      center: layout.scene.center,
+      floorTileSize: layout.scene.floorTileSize,
+    },
+    anchors: {
+      seats: layout.anchors.seats,
+      zones: layout.anchors.zones,
+      wallDecorations: layout.anchors.wallDecorations,
+    },
+  };
+}
+
+function resolveBuildingConnectors(
+  connectors: NormalizedOfficeConnectorConfig[],
+  floors: FloorResolvedLayout[],
+): ResolvedBuildingConnector[] {
+  const floorsById = new Map(floors.map((floor) => [floor.id, floor]));
+  return connectors.map((connector) => {
+    const stops = connector.serves.map((floorId) => {
+      const floor = floorsById.get(floorId);
+      if (!floor) {
+        throw new Error(`Agent game office connector ${connector.id} serves unresolved floor: ${floorId}`);
+      }
+      const stop = resolveElevatorStop(connector.id, floor);
+      addElevatorStopComponents(floor, connector.id, stop);
+      return stop;
+    });
+
+    return {
+      id: connector.id,
+      type: connector.type,
+      name: connector.name,
+      serves: connector.serves,
+      stops,
+    };
+  });
+}
+
+function resolveElevatorStop(
+  connectorId: string,
+  floor: ResolvedOfficeFloor,
+): ResolvedElevatorStop {
+  const bounds = getFloorBounds(floor);
+  const x = bounds.minX + ELEVATOR_CORE_MARGIN_X;
+  const z = bounds.minZ + ELEVATOR_CORE_MARGIN_Z;
+  return {
+    floorId: floor.id,
+    entryNodeId: `${connectorId}:${floor.id}:entry`,
+    cabinNodeId: `${connectorId}:${floor.id}:cabin`,
+    entryPosition: { x, y: floor.elevation, z: z + ELEVATOR_ENTRY_OFFSET_Z },
+    cabinPosition: { x, y: floor.elevation, z },
+  };
+}
+
+function addElevatorStopComponents(
+  floor: FloorResolvedLayout,
+  connectorId: string,
+  stop: ResolvedElevatorStop,
+) {
+  floor.components.push(
+    {
+      id: `${connectorId}:${floor.id}:door`,
+      kind: "elevatorDoor",
+      floorId: floor.id,
+      roomId: null,
+      position: { x: stop.cabinPosition.x, z: stop.cabinPosition.z },
+      props: { width: 1.5, depth: 0.18, height: 2.4 },
+    },
+    {
+      id: `${connectorId}:${floor.id}:frame`,
+      kind: "elevatorFrame",
+      floorId: floor.id,
+      roomId: null,
+      position: { x: stop.cabinPosition.x, z: stop.cabinPosition.z },
+      props: { width: 2.2, depth: 1.1, height: 2.8 },
+    },
+    {
+      id: `${connectorId}:${floor.id}:indicator`,
+      kind: "elevatorIndicator",
+      floorId: floor.id,
+      roomId: null,
+      position: { x: stop.cabinPosition.x - 1.35, y: 2.6, z: stop.cabinPosition.z },
+      props: { width: 0.45, depth: 0.08, height: 0.3 },
+    },
+  );
+}
+
+function getFloorBounds(floor: ResolvedOfficeFloor): { minX: number; maxX: number; minZ: number; maxZ: number } {
+  const bounds = createEmptyBounds();
+  for (const room of floor.rooms) {
+    const edges = getRoomEdges(room);
+    includeBounds(bounds, edges.minX, edges.minZ);
+    includeBounds(bounds, edges.maxX, edges.maxZ);
+  }
+  if (!Number.isFinite(bounds.minX)) {
+    return {
+      minX: OFFICE_FLOOR_CENTER_X - OFFICE_FLOOR_WIDTH / 2,
+      maxX: OFFICE_FLOOR_CENTER_X + OFFICE_FLOOR_WIDTH / 2,
+      minZ: -OFFICE_FLOOR_DEPTH / 2,
+      maxZ: OFFICE_FLOOR_DEPTH / 2,
+    };
+  }
+  return bounds;
+}
+
+function buildNavigationGraph(
+  floors: FloorResolvedLayout[],
+  connectors: ResolvedBuildingConnector[],
+  offstage: ResolvedOffstageAnchor,
+): ResolvedBuildingNavigationGraph {
+  const nodes: NavigationNode[] = [];
+  const edges: NavigationEdge[] = [];
+
+  for (const floor of floors) {
+    for (const anchor of floor.anchors.seats) {
+      nodes.push({
+        id: anchor.id,
+        floorId: anchor.floorId,
+        kind: "seat",
+        anchorId: anchor.id,
+        position: { x: anchor.position.x, y: floor.elevation, z: anchor.position.z },
+      });
+    }
+    for (const anchor of floor.anchors.zones) {
+      nodes.push({
+        id: `zone:${anchor.id}`,
+        floorId: anchor.floorId,
+        kind: "zone",
+        anchorId: anchor.id,
+        position: { x: anchor.position.x, y: floor.elevation, z: anchor.position.z },
+      });
+    }
+  }
+
+  nodes.push({
+    id: offstage.id,
+    floorId: null,
+    kind: "offstage",
+    anchorId: offstage.id,
+    position: offstage.position,
+  });
+
+  for (const connector of connectors) {
+    for (const stop of connector.stops) {
+      nodes.push(
+        {
+          id: stop.entryNodeId,
+          floorId: stop.floorId,
+          kind: "connector-entry",
+          connectorId: connector.id,
+          position: stop.entryPosition,
+        },
+        {
+          id: stop.cabinNodeId,
+          floorId: stop.floorId,
+          kind: "connector-cabin",
+          connectorId: connector.id,
+          position: stop.cabinPosition,
+        },
+      );
+      pushBidirectionalWalkEdge(edges, stop.entryNodeId, stop.cabinNodeId, stop.floorId);
+    }
+
+    for (let leftIndex = 0; leftIndex < connector.stops.length; leftIndex += 1) {
+      for (let rightIndex = leftIndex + 1; rightIndex < connector.stops.length; rightIndex += 1) {
+        const left = connector.stops[leftIndex]!;
+        const right = connector.stops[rightIndex]!;
+        pushBidirectionalElevatorEdge(edges, connector.id, left, right);
+      }
+    }
+  }
+
+  for (const floor of floors) {
+    const floorNodes = nodes.filter((node) =>
+      node.floorId === floor.id &&
+      (node.kind === "seat" || node.kind === "zone" || node.kind === "connector-entry")
+    );
+    for (let leftIndex = 0; leftIndex < floorNodes.length; leftIndex += 1) {
+      for (let rightIndex = leftIndex + 1; rightIndex < floorNodes.length; rightIndex += 1) {
+        pushBidirectionalWalkEdge(edges, floorNodes[leftIndex]!.id, floorNodes[rightIndex]!.id, floor.id);
+      }
+    }
+  }
+
+  return { nodes, edges };
+}
+
+function pushBidirectionalWalkEdge(
+  edges: NavigationEdge[],
+  left: string,
+  right: string,
+  floorId: string,
+) {
+  edges.push(
+    { kind: "walk", from: left, to: right, floorId },
+    { kind: "walk", from: right, to: left, floorId },
+  );
+}
+
+function pushBidirectionalElevatorEdge(
+  edges: NavigationEdge[],
+  connectorId: string,
+  left: ResolvedElevatorStop,
+  right: ResolvedElevatorStop,
+) {
+  edges.push(
+    {
+      kind: "elevator",
+      from: left.cabinNodeId,
+      to: right.cabinNodeId,
+      connectorId,
+      fromFloorId: left.floorId,
+      toFloorId: right.floorId,
+    },
+    {
+      kind: "elevator",
+      from: right.cabinNodeId,
+      to: left.cabinNodeId,
+      connectorId,
+      fromFloorId: right.floorId,
+      toFloorId: left.floorId,
+    },
+  );
+}
+
+function assembleBuildingLayout(
+  floors: FloorResolvedLayout[],
+  connectors: ResolvedBuildingConnector[],
+  offstage: ResolvedOffstageAnchor,
+): ResolvedOfficeLayout {
+  const rooms = floors.flatMap((floor) => floor.rooms);
+  const components = floors.flatMap((floor) => floor.components);
+  const floorTiles = floors.flatMap((floor) => floor.floorTiles);
+  const walls = floors.flatMap((floor) => floor.walls);
+  const aggregateOffstage = createAggregateOffstageAnchor(offstage);
+  const seats = [...floors.flatMap((floor) => floor.anchors.seats), aggregateOffstage];
+  const zones = [...floors.flatMap((floor) => floor.anchors.zones), aggregateOffstage];
+  const wallDecorations = floors.flatMap((floor) => floor.anchors.wallDecorations);
+  const bounds = createEmptyBounds();
+
+  for (const room of rooms) {
+    const edges = getRoomEdges(room);
+    includeBounds(bounds, edges.minX, edges.minZ);
+    includeBounds(bounds, edges.maxX, edges.maxZ);
+  }
+
+  const width = Number.isFinite(bounds.minX) ? bounds.maxX - bounds.minX : OFFICE_FLOOR_WIDTH;
+  const depth = Number.isFinite(bounds.minZ) ? bounds.maxZ - bounds.minZ : OFFICE_FLOOR_DEPTH;
+  const center = Number.isFinite(bounds.minX)
+    ? { x: (bounds.minX + bounds.maxX) / 2, z: (bounds.minZ + bounds.maxZ) / 2 }
+    : { x: OFFICE_FLOOR_CENTER_X, z: 0 };
+  const maxElevation = Math.max(0, ...floors.map((floor) => floor.elevation));
+
+  return {
+    building: {
+      floors,
+      connectors,
+      navigation: buildNavigationGraph(floors, connectors, offstage),
+    },
+    scene: {
+      width,
+      height: maxElevation + FLOOR_ELEVATION_STEP,
+      depth,
+      center,
+      floorTileSize: OFFICE_FLOOR_TILE_SIZE,
+      floorTiles,
+      walls,
+      lights: [
+        { id: "ambient", kind: "ambient", color: 0xffffff, intensity: 0.7 },
+        { id: "directional", kind: "directional", color: 0xffffff, intensity: 1.2, position: { x: 10, y: 18 + maxElevation, z: 8 } },
+      ],
+    },
+    rooms,
+    components,
+    anchors: {
+      seats,
+      zones,
+      wallDecorations,
+      offstage,
+    },
+  };
 }
 
 export function resolveOfficeAgentAnchor(
   layout: ResolvedOfficeLayout,
   agent: AgentGameOfficeAgent,
 ): ResolvedSeatAnchor {
+  if (agent.zoneId === "offstage") {
+    return layout.anchors.offstage as unknown as ResolvedSeatAnchor;
+  }
+
   const candidates = sortPreferredAnchors(layout, layout.anchors.seats
     .filter((anchor) => anchor.zoneId === agent.zoneId)
     .sort(compareAnchorId), agent.zoneId);
@@ -281,7 +679,7 @@ export function resolveOfficeAgentAnchor(
     return available[stableHash(agent.id) % available.length]!;
   }
 
-  return layout.anchors.offstage;
+  return layout.anchors.offstage as unknown as ResolvedSeatAnchor;
 }
 
 function sortPreferredAnchors(
@@ -307,7 +705,7 @@ function addOfficePreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom
     addComponent(layout, room.id, "desk", `desk-${index + 1}`, slot.desk.x, slot.desk.z);
     addComponent(layout, room.id, "officeChair", `desk-chair-${index + 1}`, slot.seat.x, slot.seat.z, { rotation: slot.rotation });
     addComponent(layout, room.id, "monitor", `monitor-${index + 1}`, slot.desk.x, slot.desk.z - 0.4);
-    addSeat(layout, room.id, `desk-${index + 1}`, "desk", slot.seat.x, slot.seat.z, { x: scaleOfficeX(-7), z: scaleOfficeZ(-5) });
+    addSeat(layout, room.id, `desk-${index + 1}`, "desk", slot.seat.x, slot.seat.z, { x: slot.desk.x, z: slot.desk.z - 0.4 });
   });
 
   MEETING_ROOMS.forEach((meetingRoom, roomIndex) => {
@@ -462,8 +860,164 @@ function addGymPreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
   }
 }
 
+function addDiningPreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
+  const tableCenters = [
+    { x: scaleOfficeX(42), z: scaleOfficeZ(-5.2) },
+    { x: scaleOfficeX(50), z: scaleOfficeZ(-5.2) },
+    { x: scaleOfficeX(42), z: scaleOfficeZ(2.8) },
+    { x: scaleOfficeX(50), z: scaleOfficeZ(2.8) },
+  ];
+  const seatsPerTable = 4;
+  const maxSeats = Math.min(room.capacity, tableCenters.length * seatsPerTable);
+
+  tableCenters.forEach((center, tableIndex) => {
+    addComponent(layout, room.id, "diningTable", `dining-table-${tableIndex + 1}`, center.x, center.z);
+    addComponent(layout, room.id, "tableCup", `dining-cup-${tableIndex + 1}-1`, center.x - 0.45, center.z - 0.28);
+    addComponent(layout, room.id, "tableCup", `dining-cup-${tableIndex + 1}-2`, center.x + 0.45, center.z + 0.28);
+
+    [
+      { x: center.x - 1.55, z: center.z, rotation: -Math.PI / 2 },
+      { x: center.x + 1.55, z: center.z, rotation: Math.PI / 2 },
+      { x: center.x, z: center.z - 1.25, rotation: 0 },
+      { x: center.x, z: center.z + 1.25, rotation: Math.PI },
+    ].forEach((seat, seatIndex) => {
+      const seatNumber = tableIndex * seatsPerTable + seatIndex + 1;
+      if (seatNumber > maxSeats) {
+        return;
+      }
+      addComponent(layout, room.id, "officeChair", `dining-chair-${seatNumber}`, seat.x, seat.z, {
+        rotation: seat.rotation,
+      });
+      addSeat(layout, room.id, `dining-${seatNumber}`, seatNumber % 3 === 0 ? "lounge" : "pantry", seat.x, seat.z, center);
+    });
+  });
+
+  addComponent(layout, room.id, "teaCounter", "serving-counter", scaleOfficeX(58.5), scaleOfficeZ(-8.8));
+  addComponent(layout, room.id, "waterDispenser", "dining-water-dispenser", scaleOfficeX(61.2), scaleOfficeZ(-8.7));
+  addComponent(layout, room.id, "kitchenCounter", "kitchen-counter", scaleOfficeX(57.8), scaleOfficeZ(8.8));
+  addComponent(layout, room.id, "kitchenStove", "kitchen-stove", scaleOfficeX(61.0), scaleOfficeZ(8.7));
+  addComponent(layout, room.id, "kitchenFridge", "kitchen-fridge", scaleOfficeX(53.9), scaleOfficeZ(8.8));
+  addSeat(layout, room.id, "serving-queue-1", "pantry", scaleOfficeX(57.5), scaleOfficeZ(-6.6), {
+    x: scaleOfficeX(58.5),
+    z: scaleOfficeZ(-8.8),
+  });
+  addSeat(layout, room.id, "serving-queue-2", "pantry", scaleOfficeX(60.2), scaleOfficeZ(-6.6), {
+    x: scaleOfficeX(58.5),
+    z: scaleOfficeZ(-8.8),
+  });
+  addSeat(layout, room.id, "kitchen-prep-1", "pantry", scaleOfficeX(57.2), scaleOfficeZ(6.8), {
+    x: scaleOfficeX(57.8),
+    z: scaleOfficeZ(8.8),
+  });
+  addSeat(layout, room.id, "kitchen-prep-2", "pantry", scaleOfficeX(60.4), scaleOfficeZ(6.8), {
+    x: scaleOfficeX(61.0),
+    z: scaleOfficeZ(8.7),
+  });
+}
+
+function addCafePreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
+  const counterX = scaleOfficeX(55.7);
+  const counterZ = scaleOfficeZ(-8.8);
+  const tableCenters = [
+    { x: scaleOfficeX(40.5), z: scaleOfficeZ(-4.9) },
+    { x: scaleOfficeX(47.5), z: scaleOfficeZ(-4.9) },
+    { x: scaleOfficeX(40.5), z: scaleOfficeZ(3.1) },
+    { x: scaleOfficeX(47.5), z: scaleOfficeZ(3.1) },
+  ];
+  const seatsPerTable = 3;
+  const maxTableSeats = Math.min(room.capacity, tableCenters.length * seatsPerTable);
+
+  addComponent(layout, room.id, "cafeCounter", "coffee-counter", counterX, counterZ);
+  addComponent(layout, room.id, "waterDispenser", "cafe-water-dispenser", scaleOfficeX(60.2), scaleOfficeZ(-8.7));
+  addComponent(layout, room.id, "tableCup", "counter-cup-1", counterX - 0.8, counterZ - 0.15);
+  addComponent(layout, room.id, "tableCup", "counter-cup-2", counterX - 0.35, counterZ + 0.1);
+  addSeat(layout, room.id, "barista-1", "pantry", counterX - 0.4, scaleOfficeZ(-7.35), { x: counterX, z: counterZ });
+  addSeat(layout, room.id, "pickup-1", "pantry", counterX + 1.25, scaleOfficeZ(-6.7), { x: counterX, z: counterZ });
+
+  tableCenters.forEach((center, tableIndex) => {
+    addComponent(layout, room.id, "cafeTable", `cafe-table-${tableIndex + 1}`, center.x, center.z);
+    addComponent(layout, room.id, "tableCup", `cafe-cup-${tableIndex + 1}-1`, center.x - 0.28, center.z - 0.18);
+    addComponent(layout, room.id, "tableCup", `cafe-cup-${tableIndex + 1}-2`, center.x + 0.25, center.z + 0.2);
+
+    [
+      { x: center.x - 1.25, z: center.z, rotation: -Math.PI / 2 },
+      { x: center.x + 1.25, z: center.z, rotation: Math.PI / 2 },
+      { x: center.x, z: center.z + 1.08, rotation: Math.PI },
+    ].forEach((seat, seatIndex) => {
+      const seatNumber = tableIndex * seatsPerTable + seatIndex + 1;
+      if (seatNumber > maxTableSeats) {
+        return;
+      }
+      addComponent(layout, room.id, "officeChair", `cafe-chair-${seatNumber}`, seat.x, seat.z, {
+        rotation: seat.rotation,
+      });
+      addSeat(layout, room.id, `cafe-seat-${seatNumber}`, "lounge", seat.x, seat.z, center);
+    });
+  });
+}
+
+function addSkyGardenPreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
+  const centerX = scaleOfficeX(16);
+  const centerZ = scaleOfficeZ(0);
+  addComponent(layout, room.id, "gardenPath", "main-path", centerX, centerZ, {
+    props: { width: 31, depth: 3.2 },
+  });
+  addComponent(layout, room.id, "gardenPath", "cross-path", centerX, centerZ, {
+    rotation: Math.PI / 2,
+    props: { width: 14, depth: 2.6 },
+  });
+
+  [
+    { id: "north-west", x: scaleOfficeX(-7), z: scaleOfficeZ(-7.6) },
+    { id: "north-east", x: scaleOfficeX(39), z: scaleOfficeZ(-7.6) },
+    { id: "south-west", x: scaleOfficeX(-7), z: scaleOfficeZ(7.6) },
+    { id: "south-east", x: scaleOfficeX(39), z: scaleOfficeZ(7.6) },
+  ].forEach((planter) => {
+    addComponent(layout, room.id, "gardenPlanter", `planter-${planter.id}`, planter.x, planter.z);
+  });
+
+  [
+    { id: "tree-1", x: scaleOfficeX(2), z: scaleOfficeZ(-5.4) },
+    { id: "tree-2", x: scaleOfficeX(30), z: scaleOfficeZ(-5.4) },
+    { id: "tree-3", x: scaleOfficeX(2), z: scaleOfficeZ(5.4) },
+    { id: "tree-4", x: scaleOfficeX(30), z: scaleOfficeZ(5.4) },
+  ].forEach((tree) => {
+    addComponent(layout, room.id, "gardenTree", tree.id, tree.x, tree.z);
+  });
+
+  [
+    { id: "bench-north", x: centerX, z: scaleOfficeZ(-5.7), rotation: 0 },
+    { id: "bench-south", x: centerX, z: scaleOfficeZ(5.7), rotation: Math.PI },
+    { id: "bench-west", x: scaleOfficeX(5.5), z: centerZ, rotation: -Math.PI / 2 },
+    { id: "bench-east", x: scaleOfficeX(26.5), z: centerZ, rotation: Math.PI / 2 },
+  ].forEach((bench, index) => {
+    addComponent(layout, room.id, "gardenBench", bench.id, bench.x, bench.z, {
+      rotation: bench.rotation,
+    });
+    addSeat(layout, room.id, `garden-seat-${index + 1}`, index < 2 ? "reading" : "lounge", bench.x, bench.z, {
+      x: centerX,
+      z: centerZ,
+    });
+  });
+
+  const extraCount = Math.max(0, Math.min(room.capacity, 12) - 4);
+  for (let index = 0; index < extraCount; index += 1) {
+    const angle = (index / Math.max(1, extraCount)) * Math.PI * 2;
+    addSeat(
+      layout,
+      room.id,
+      `garden-open-${index + 1}`,
+      index % 2 === 0 ? "lounge" : "reading",
+      centerX + Math.cos(angle) * 4.2,
+      centerZ + Math.sin(angle) * 3.6,
+      { x: centerX, z: centerZ },
+    );
+  }
+}
+
 function createRoom(
   id: string,
+  floorId: string,
   type: AgentGameOfficeRoomType,
   capacity: number,
   index: number,
@@ -474,6 +1028,7 @@ function createRoom(
   const isOffice = type === "office";
   return {
     id,
+    floorId,
     type,
     capacity,
     bounds: {
@@ -519,6 +1074,7 @@ function applyAdaptiveSceneBounds(layout: MutableResolvedLayout) {
     if (!bounds) {
       return {
         id: `floor-${room.id}`,
+        floorId: room.floorId,
         color: getRoomFloorColor(room.type),
         x: center.x,
         z: center.z,
@@ -539,6 +1095,7 @@ function applyAdaptiveSceneBounds(layout: MutableResolvedLayout) {
     };
     return {
       id: `floor-${room.id}`,
+      floorId: room.floorId,
       color: getRoomFloorColor(room.type),
       x: room.bounds.x,
       z: room.bounds.z,
@@ -563,6 +1120,12 @@ function getRoomFloorColor(type: AgentGameOfficeRoomType): number {
       return 0xdbe4ec;
     case "gym":
       return 0xd7e3d2;
+    case "dining":
+      return 0xeadfc8;
+    case "cafe":
+      return 0xe8ddcf;
+    case "skyGarden":
+      return 0xd9ead2;
   }
 }
 
@@ -808,6 +1371,7 @@ function createRoomWall(
   const isHorizontal = side === "north" || side === "south";
   return {
     id: `${room.id}:${side}-wall`,
+    floorId: room.floorId,
     roomId: room.id,
     side,
     color: 0xe8e0d0,
@@ -883,6 +1447,26 @@ function getComponentFootprint(component: ResolvedOfficeComponentInstance): { wi
       return { width: 1.4, depth: 0.4 };
     case "meetingTable":
       return { width: 5, depth: component.props?.depth ?? 3 };
+    case "diningTable":
+      return { width: 2.6, depth: 1.8 };
+    case "cafeCounter":
+      return { width: 4.2, depth: 0.9 };
+    case "cafeTable":
+      return { width: 1.7, depth: 1.7 };
+    case "kitchenCounter":
+      return { width: 4.8, depth: 0.9 };
+    case "kitchenStove":
+      return { width: 1.5, depth: 0.9 };
+    case "kitchenFridge":
+      return { width: 1.1, depth: 0.9 };
+    case "gardenPlanter":
+      return { width: 4.4, depth: 1.2 };
+    case "gardenTree":
+      return { width: 1.8, depth: 1.8 };
+    case "gardenBench":
+      return { width: 3.2, depth: 1 };
+    case "gardenPath":
+      return { width: component.props?.width ?? 4, depth: component.props?.depth ?? 1 };
     case "meetingGlassRoom":
       return { width: 11.7 * OFFICE_LAYOUT_SCALE, depth: component.props?.depth ?? 8 * OFFICE_LAYOUT_SCALE };
     case "largeMeetingTable":
@@ -925,6 +1509,12 @@ function getComponentFootprint(component: ResolvedOfficeComponentInstance): { wi
       return { width: 1.4, depth: 3.2 };
     case "gymMirror":
       return { width: component.props?.width ?? 5.2, depth: 0.2 };
+    case "elevatorDoor":
+      return { width: component.props?.width ?? 1.5, depth: component.props?.depth ?? 0.18 };
+    case "elevatorFrame":
+      return { width: component.props?.width ?? 2.2, depth: component.props?.depth ?? 1.1 };
+    case "elevatorIndicator":
+      return { width: component.props?.width ?? 0.45, depth: component.props?.depth ?? 0.08 };
     case "glassWall":
     case "glassDoor":
       return { width: component.props?.width ?? 1, depth: component.props?.depth ?? 1 };
@@ -948,6 +1538,7 @@ function addComponent(
   layout.components.push({
     id: `${roomId}:${id}`,
     kind,
+    floorId: resolveRoomFloorId(layout, roomId),
     roomId,
     position: { x, y: options.y, z },
     rotation: options.rotation,
@@ -970,6 +1561,7 @@ function addWallDecoration(
   layout.anchors.wallDecorations.push({
     id: `${room.id}:${id}`,
     roomId: room.id,
+    floorId: room.floorId,
     position: { x, z },
     rotation,
     faceDirection,
@@ -985,12 +1577,13 @@ function addSeat(
   z: number,
   facing: { x: number; z: number },
 ) {
-  const anchor = createAnchor(roomId, id, zoneId, roomId, x, z, facing);
+  const anchor = createAnchor(resolveRoomFloorId(layout, roomId), roomId, id, zoneId, roomId, x, z, facing);
   layout.anchors.seats.push(anchor);
   layout.anchors.zones.push(anchor);
 }
 
 function createAnchor(
+  floorId: string,
   roomId: string,
   id: string,
   zoneId: AgentGameOfficeZoneId,
@@ -1002,12 +1595,50 @@ function createAnchor(
   return {
     id: `${roomId}:${id}`,
     roomId: anchorRoomId,
+    floorId,
     zoneId,
     position: { x, z },
     facing,
   };
 }
 
+function createOffstageAnchor(): ResolvedOffstageAnchor {
+  return {
+    id: "offstage",
+    roomId: null,
+    floorId: null,
+    zoneId: "offstage",
+    position: { x: scaleOfficeX(-13), y: 0, z: scaleOfficeZ(8) },
+  };
+}
+
+function createAggregateOffstageAnchor(offstage: ResolvedOffstageAnchor): ResolvedSeatAnchor {
+  return {
+    id: offstage.id,
+    roomId: "offstage",
+    floorId: "offstage",
+    zoneId: offstage.zoneId,
+    position: { x: offstage.position.x, z: offstage.position.z },
+    facing: { x: offstage.position.x, z: offstage.position.z },
+  };
+}
+
+function resolveRoomId(room: NormalizedOfficeRoomConfig, useLegacyRoomIds: boolean): string {
+  if (!useLegacyRoomIds) {
+    return room.id;
+  }
+  const separatorIndex = room.id.indexOf(":");
+  return separatorIndex === -1 ? room.id : room.id.slice(separatorIndex + 1);
+}
+
+function resolveRoomFloorId(layout: MutableResolvedLayout, roomId: string): string {
+  const floorId = layout.rooms.find((room) => room.id === roomId)?.floorId;
+  if (!floorId) {
+    throw new Error(`Unknown office room for floor-owned layout content: ${roomId}`);
+  }
+  return floorId;
+}
+
 function compareAnchorId(left: ResolvedSeatAnchor, right: ResolvedSeatAnchor): number {
   return left.id.localeCompare(right.id);
 }