feat(core): let a vertical opening answer per surface, not per level

A level's slab and its ceiling sit at opposite ends of the level, so a
shaft crossing floors 1-3 cuts slabs 2 and 3 but ceilings 1 and 2. The
predicate saw only the level id, so a kind had one answer for both
surfaces and was necessarily wrong at one end: slab semantics leave the
bottom floor's ceiling sealed across the shaft, ceiling semantics cut a
hole in the ceiling above the top stop.

The elevator has always had two predicates for exactly this reason; the
capability handed plugins a single one. Pass the surface kind — the sync
already holds the surface node, so it costs one argument — and the two
sides can express the same rule.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01T5bdAFduH4BkPCjvtJgFzn

Author: claude

packages/core/src/registry/types.ts

@@ -2177,11 +2177,23 @@ export type VerticalOpeningConfig = {
    */
   polygon: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) => Array<[number, number]>
   /**
-   * Whether this node passes through the given level's floor. Called once per
+   * Whether this node passes through the given surface. Called once per
    * candidate surface, so the kind decides its own service range — a lift
    * serving floors 1-3 answers true for 2 and 3 and false for 4.
-   */
-  servesLevel: (node: AnyNode, levelId: string, nodes: Readonly<Record<string, AnyNode>>) => boolean
+   *
+   * `surface` matters because a level's slab and its ceiling sit at opposite
+   * ends of the level: for a shaft spanning floors 1-3 the cut slabs are 2 and
+   * 3, while the cut ceilings are 1 and 2. A predicate that cannot tell them
+   * apart is wrong at one end or the other — it either leaves the ceiling of
+   * the bottom floor sealed across the shaft, or cuts a hole in the ceiling of
+   * the top one.
+   */
+  servesLevel: (
+    node: AnyNode,
+    levelId: string,
+    nodes: Readonly<Record<string, AnyNode>>,
+    surface: 'slab' | 'ceiling',
+  ) => boolean
 }
 
 export type FloorPlacedConfig = {

packages/core/src/systems/elevator/elevator-opening-sync.test.ts

@@ -305,4 +305,52 @@ describe('verticalOpening capability', () => {
     expect(update?.data.holeMetadata?.[0]?.source).toBe('manual')
     expect(update?.data.holeMetadata?.[1]?.source).toBe('verticalOpening')
   })
+
+  /**
+   * A level's slab and its ceiling sit at opposite ends of the level, so a
+   * shaft crosses different sets of them: floors 1-3 means slabs 2 and 3 but
+   * ceilings 1 and 2. Without the surface argument the kind answers one
+   * question for both and is wrong at one end — here, sealing the ceiling
+   * across the shaft or cutting the ceiling of the top floor.
+   */
+  test('lets the kind answer per surface', () => {
+    registerNode({
+      kind: 'test:lift',
+      schemaVersion: 1,
+      schema: {} as never,
+      category: 'furnish',
+      defaults: () => ({}) as never,
+      capabilities: {
+        verticalOpening: {
+          polygon: () => [
+            [-1, -1],
+            [1, -1],
+            [1, 1],
+            [-1, 1],
+          ],
+          servesLevel: (_node, _levelId, _nodes, surface) => surface === 'slab',
+        },
+      },
+      presentation: { label: 'Lift', icon: { kind: 'iconify', name: 'lucide:square' } },
+    } as never)
+
+    const { nodes, slabId } = sceneWithLift()
+    const ground = Object.values(nodes).find((node) => node.type === 'level')!
+    const ceiling = CeilingNode.parse({
+      name: 'Ceiling',
+      parentId: ground.id,
+      polygon: [
+        [-10, -10],
+        [10, -10],
+        [10, 10],
+        [-10, 10],
+      ],
+    })
+    nodes[ceiling.id] = ceiling as AnyNode
+
+    const updates = syncAutoElevatorOpenings(nodes)
+
+    expect(updates.find((u) => u.id === slabId)?.data.holes).toHaveLength(1)
+    expect(updates.find((u) => u.id === ceiling.id)).toBeUndefined()
+  })
 })

packages/core/src/systems/elevator/elevator-opening-sync.ts

@@ -232,7 +232,7 @@ export function syncAutoElevatorOpenings(nodes: Record<string, AnyNode>) {
       }))
 
     const declaredHoles = openingOwners
-      .filter(({ node, config }) => config.servesLevel(node, levelId, nodes))
+      .filter(({ node, config }) => config.servesLevel(node, levelId, nodes, surface.type))
       .map(({ node, config }) => ({
         polygon: config.polygon(node, nodes) as Point2D[],
         metadata: { ownerId: node.id, source: 'verticalOpening' as const },