@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/paint-scope.ts

@@ -1,10 +1,16 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  floorStepRole,
   generateSceneMaterialId,
+  getWallLevelZones,
+  getWallLocalFaceZ,
+  getWallZoneSpans,
   type ItemNode,
   type MaterialSchema,
   nodeRegistry,
+  parseFloorStepRole,
+  parseRoomFinishRole,
   pointInPolygon2D,
   resolveLevelId,
   type SceneMaterial,
@@ -15,6 +21,7 @@ import {
   toSceneMaterialRef,
   useScene,
   type WallNode,
+  wallRoomFinishRole,
 } from '@pascal-app/core'
 
 /**
@@ -36,6 +43,8 @@ export type PaintHoverInfo = {
   slotLabel: string
   /** Kind noun for the `'object'` label (e.g. "Whole shelf"). */
   nodeNoun: string
+  /** Labels a surface names itself, per scope, over the generic ones. */
+  labels?: Partial<Record<PaintScope, string>>
 }
 
 function nodeHasAsset(node: AnyNode): boolean {
@@ -46,13 +55,55 @@ function nodeOffersRoomScope(node: AnyNode): boolean {
   return nodeRegistry.get(node.type)?.capabilities?.paint?.roomScope === true
 }
 
+const isFloorPlate = (node: AnyNode): boolean => node.type === 'slab' && node.boundary === 'auto'
+
+const FOOTPRINT_FACE_LABELS: Record<string, string> = {
+  edge: 'Floor edge · all around this floor',
+  riser: 'Riser · all around this floor',
+  underside: 'Underside · all of this floor',
+  foundation: 'Foundation · all around this floor',
+}
+
+/**
+ * The scopes a generated floor plate offers for the surface under the cursor.
+ * A plate is not an object anyone paints whole: a room's floor is "this
+ * surface" (the painted part under the cursor, else the room floor) or the
+ * whole room; a step is its doorway or every step of the room; the footprint's
+ * faces are one finish all around the floor, so they have nothing to cycle.
+ */
+export function platePaintScopes(
+  node: AnyNode,
+  role: string,
+): { scopes: PaintScope[]; labels: Partial<Record<PaintScope, string>> } | null {
+  if (node.type !== 'slab' || node.boundary !== 'auto') return null
+  if (parseFloorStepRole(role))
+    return {
+      scopes: ['single', 'room'],
+      labels: { single: 'This step', room: 'All steps in this room' },
+    }
+  if (parseRoomFinishRole(role))
+    return { scopes: ['single', 'room'], labels: { single: 'This surface', room: 'Whole room' } }
+  const fixed = node.plateRole === 'base' ? FOOTPRINT_FACE_LABELS[role] : undefined
+  return { scopes: ['single'], labels: fixed ? { single: fixed } : {} }
+}
+
 /**
  * The scopes a hovered node offers, derived from the node itself: every node
  * paints `single`; > 1 slot adds `object`; an `asset` adds `matching`; a
  * `roomScope`-declaring kind adds `room`. `slotRoles` is the node's full slot set
- * (declared or mesh-derived), passed in by the caller.
+ * (declared or mesh-derived), passed in by the caller. A floor plate's set
+ * depends on the surface under the cursor (`role`).
  */
-export function availablePaintScopes(args: { node: AnyNode; slotRoles: string[] }): PaintScope[] {
+export function availablePaintScopes(args: {
+  node: AnyNode
+  slotRoles: string[]
+  role?: string
+}): PaintScope[] {
+  // A wall paints the face under the cursor, or its room's walls: "whole wall"
+  // (both faces of one wall, across two rooms) is nobody's surface.
+  if (args.node.type === 'wall') return ['single', 'room']
+  const plate = args.role === undefined ? null : platePaintScopes(args.node, args.role)
+  if (plate) return plate.scopes
   const scopes: PaintScope[] = ['single']
   if (args.slotRoles.length > 1) scopes.push('object')
   if (nodeHasAsset(args.node)) scopes.push('matching')
@@ -66,7 +117,24 @@ export function cyclePaintScope(scope: PaintScope, scopes: PaintScope[]): PaintS
   return list[(index + 1) % list.length] ?? 'single'
 }
 
+/** The chip's hover info for `role` on `node`: its scopes and what each is called. */
+export function paintHoverInfo(node: AnyNode, role: string, slotRoles: string[]): PaintHoverInfo {
+  return {
+    scopes: availablePaintScopes({ node, slotRoles, role }),
+    slotLabel: paintSurfaceLabel(node, role),
+    nodeNoun: node.type,
+    labels: platePaintScopes(node, role)?.labels,
+  }
+}
+
+/** The scope a click applies: the chosen one when the hovered surface offers it. */
+export function effectivePaintScope(scope: PaintScope, scopes: PaintScope[]): PaintScope {
+  return scopes.includes(scope) ? scope : 'single'
+}
+
 export function paintScopeLabel(scope: PaintScope, info: PaintHoverInfo): string {
+  const own = info.labels?.[scope]
+  if (own) return own
   switch (scope) {
     case 'object':
       return `Whole ${info.nodeNoun}`
@@ -91,13 +159,21 @@ export function nodeSlotRoles(node: AnyNode, meshSlotRoles: (node: AnyNode) => s
   return meshSlotRoles(node)
 }
 
+/**
+ * What the paint HUD calls the surface under the cursor: a wall face is the
+ * "Face" (the narrow scope), a trim its own name, anything else its slot.
+ */
+export function paintSurfaceLabel(node: AnyNode, role: string): string {
+  if (node.type === 'wall' && !WALL_TRIM_ROLE.test(role)) return 'Face'
+  return slotDisplayLabel(node, role)
+}
+
 /** Display label for the hovered slot — declared label wins, else derived from the id. */
 export function slotDisplayLabel(node: AnyNode, role: string): string {
-  const declared = nodeRegistry
-    .get(node.type)
-    ?.capabilities?.slots?.(node)
-    ?.find((slot) => slot.slotId === role)
-  return declared?.label ?? slotLabelFromId(role)
+  const capabilities = nodeRegistry.get(node.type)?.capabilities
+  const declared = capabilities?.slots?.(node)?.find((slot) => slot.slotId === role)
+  if (declared) return declared.label
+  return capabilities?.paint?.roleLabel?.(node, role) ?? slotLabelFromId(role)
 }
 
 // ── Fan-out resolution ──────────────────────────────────────────────────────
@@ -141,17 +217,87 @@ function distanceToPolyline(
   return distance
 }
 
-function wallRoleForRoomFace(role: string, wall: WallNode, face: 'front' | 'back'): string | null {
-  const semantic = face === 'front' ? wall.frontSide : wall.backSide
-  const fallback = face === 'front' ? 'interior' : 'exterior'
-  const side = semantic === 'interior' || semantic === 'exterior' ? semantic : fallback
+const WALL_TRIM_ROLE = /^([ab])(Skirting|Crown|ChairRail)$/
+const WALL_ROOM_FACE_ROLE = /^room:(.+)\/([ab])$/
+
+/** The same surface on a boundary face: face slots and trims follow the physical face. */
+function wallRoleForRoomFace(role: string, face: 'front' | 'back'): string | null {
+  const physical = face === 'front' ? 'a' : 'b'
+  if (role === 'a' || role === 'b') return physical
+  const trim = WALL_TRIM_ROLE.exec(role)
+  return trim ? `${physical}${trim[2]}` : null
+}
+
+/** The face a wall paint role sits on, when the role names one. */
+function wallRoleFace(role: string): 'a' | 'b' | null {
+  if (role === 'a' || role === 'b') return role
+  return (WALL_TRIM_ROLE.exec(role)?.[1] ?? WALL_ROOM_FACE_ROLE.exec(role)?.[2] ?? null) as
+    | 'a'
+    | 'b'
+    | null
+}
+
+/** The room (zone) a wall face borders at the hit point, from the zones' boundary spans. */
+function zoneAtWallHit(
+  wall: WallNode,
+  face: 'a' | 'b',
+  point: readonly [number, number],
+  nodes: Record<string, AnyNode>,
+): string | null {
+  const dx = wall.end[0] - wall.start[0]
+  const dz = wall.end[1] - wall.start[1]
+  const lengthSquared = dx * dx + dz * dz
+  if (lengthSquared < 1e-12) return null
+  const t = ((point[0] - wall.start[0]) * dx + (point[1] - wall.start[1]) * dz) / lengthSquared
+  const spans = getWallZoneSpans(wall, getWallLevelZones(wall, nodes))
+  const span = spans.find(
+    (candidate) =>
+      candidate.face === face &&
+      t >= candidate.t0 - 1e-6 &&
+      (t < candidate.t1 || (candidate.t1 >= 1 && t <= 1 + 1e-6)),
+  )
+  return span?.zoneId ?? null
+}
 
-  if (role === 'interior' || role === 'exterior') return side
-  if (role.endsWith('Interior'))
-    return `${role.slice(0, -'Interior'.length)}${side === 'interior' ? 'Interior' : 'Exterior'}`
-  if (role.endsWith('Exterior'))
-    return `${role.slice(0, -'Exterior'.length)}${side === 'interior' ? 'Interior' : 'Exterior'}`
-  return null
+/**
+ * Room scope on a wall face inside a room paints the room's wall finish: one
+ * `room:<zoneId>` commit on the zone. Every wall bordering the room is listed so
+ * each previews the change; trims fan out to the face each wall turns to the room.
+ */
+function wallRoomTargets(
+  wall: WallNode,
+  role: string,
+  zoneId: string,
+  nodes: Record<string, AnyNode>,
+): Array<{ nodeId: AnyNodeId; role: string }> {
+  const zone = nodes[zoneId]
+  if (zone?.type !== 'zone') return []
+  const walls = [
+    wall,
+    ...zone.boundaryWallIds
+      .map((id) => nodes[id])
+      .filter((node): node is WallNode => node?.type === 'wall' && node.id !== wall.id),
+  ]
+  const trim = WALL_TRIM_ROLE.exec(role)
+  if (trim) {
+    const targets = new Map<string, { nodeId: AnyNodeId; role: string }>()
+    for (const target of walls) {
+      for (const span of getWallZoneSpans(target, [zone])) {
+        const targetRole = `${span.face}${trim[2]}`
+        targets.set(`${target.id}:${targetRole}`, {
+          nodeId: target.id as AnyNodeId,
+          role: targetRole,
+        })
+      }
+    }
+    return [...targets.values()]
+  }
+  const roomRole = wallRoomFinishRole(zoneId)
+  const targets = walls.map((target) => ({ nodeId: target.id as AnyNodeId, role: roomRole }))
+  // A room bounded by one wall still commits through the fan-out path, which
+  // routes the room role to the zone; the zone target itself previews nothing.
+  if (targets.length === 1) targets.push({ nodeId: zone.id as AnyNodeId, role: roomRole })
+  return targets
 }
 
 function resolveWallPaintSpace(args: {
@@ -162,7 +308,13 @@ function resolveWallPaintSpace(args: {
 }): Space | null {
   const { wall, wallHit, nodes, spaces } = args
   const levelId = wall.parentId ?? resolveLevelId(wall, nodes)
-  const tolerance = (wall.thickness ?? 0.2) / 2 + 0.08
+  const tolerance =
+    getWallLocalFaceZ(
+      { ...wall, thickness: wall.thickness ?? 0.2 },
+      wallHit.face === 'front' ? 'a' : 'b',
+    ) *
+      (wallHit.face === 'front' ? 1 : -1) +
+    0.08
   let best: { space: Space; distance: number } | null = null
 
   for (const space of Object.values(spaces)) {
@@ -185,6 +337,7 @@ function boundaryPointKey(point: readonly [number, number]): string {
 function boundarySegmentKey(boundary: WallBoundaryFace): string {
   const forward = boundary.points.map(boundaryPointKey).join('|')
   const reverse = [...boundary.points].reverse().map(boundaryPointKey).join('|')
+  // biome-ignore lint/complexity/useMathMinMax: lexicographic string comparison
   return `${boundary.wallId}:${forward < reverse ? forward : reverse}`
 }
 
@@ -216,7 +369,13 @@ function connectedExteriorBoundaries(args: {
     if (!boundary) return []
     return [{ ...boundary, face: oppositeWallFace(boundary.face) }]
   })
-  const tolerance = (wall.thickness ?? 0.2) / 2 + 0.08
+  const tolerance =
+    getWallLocalFaceZ(
+      { ...wall, thickness: wall.thickness ?? 0.2 },
+      wallHit.face === 'front' ? 'a' : 'b',
+    ) *
+      (wallHit.face === 'front' ? 1 : -1) +
+    0.08
   const seed = exterior
     .filter((boundary) => boundary.wallId === wall.id && boundary.face === wallHit.face)
     .map((boundary) => ({ boundary, distance: distanceToPolyline(wallHit.point, boundary.points) }))
@@ -277,7 +436,7 @@ function wallTargetsForBoundaries(args: {
     ) {
       continue
     }
-    const targetRole = wallRoleForRoomFace(role, targetWall, boundary.face)
+    const targetRole = wallRoleForRoomFace(role, boundary.face)
     if (!targetRole) continue
     const key = `${targetWall.id}:${targetRole}`
     targets.set(key, { nodeId: targetWall.id as AnyNodeId, role: targetRole })
@@ -298,6 +457,20 @@ function polygonCentroid(
   return [x / points.length, z / points.length]
 }
 
+/**
+ * The role one paint click writes under `scope`: a floor step paints its own
+ * doorway, and in the room scope every step of its room (`step:<zoneId>`); a
+ * room's floor in the room scope is the whole room (`room:<zoneId>/*`).
+ * Hover outline, preview and commit all start from this role.
+ */
+export function paintScopeRole(node: AnyNode, role: string, scope: PaintScope): string {
+  if (node.type !== 'slab' || scope !== 'room') return role
+  const step = parseFloorStepRole(role)
+  if (step) return floorStepRole(step.zoneId)
+  const floor = isFloorPlate(node) ? parseRoomFinishRole(role) : null
+  return floor ? `room:${floor.zoneId}/*` : role
+}
+
 /**
  * Expand one paint hit (`node` + resolved `role`) into the full list of
  * (node, role) targets the current `scope` should paint. Returns just the
@@ -318,8 +491,21 @@ export function resolvePaintScopeTargets(args: {
   slotRolesOf: (node: AnyNode) => string[]
   wallHit?: WallPaintHit
 }): Array<{ nodeId: AnyNodeId; role: string }> {
-  const { node, role, scope, nodes, spaces, slotRolesOf, wallHit } = args
+  const { node, role, nodes, spaces, slotRolesOf, wallHit } = args
+  const plateScopes = platePaintScopes(node, role)?.scopes
+  const scope = plateScopes ? effectivePaintScope(args.scope, plateScopes) : args.scope
   const single = [{ nodeId: node.id as AnyNodeId, role }]
+  if (node.type === 'slab' && parseFloorStepRole(role)) {
+    // A room's steps are drawn by whichever plates carry them.
+    const stepRole = paintScopeRole(node, role, scope)
+    const targets = Object.values(nodes)
+      .filter(
+        (other) =>
+          other.type === 'slab' && other.parentId === node.parentId && other.boundary === 'auto',
+      )
+      .map((other) => ({ nodeId: other.id, role: stepRole }))
+    return targets.length ? targets : [{ nodeId: node.id as AnyNodeId, role: stepRole }]
+  }
   if (scope === 'single') return single
 
   // Whole object: paint every slot of the clicked node. Generic across any
@@ -344,6 +530,13 @@ export function resolvePaintScopeTargets(args: {
     if (!wallHit) return single
     const levelId = wall.parentId ?? resolveLevelId(wall, nodes)
     if (!levelId) return single
+    const face = wallRoleFace(role) ?? (wallHit.face === 'front' ? 'a' : 'b')
+    const zoneId =
+      WALL_ROOM_FACE_ROLE.exec(role)?.[1] ?? zoneAtWallHit(wall, face, wallHit.point, nodes)
+    if (zoneId) {
+      const targets = wallRoomTargets(wall, role, zoneId, nodes)
+      if (targets.length > 0) return targets
+    }
     const space = resolveWallPaintSpace({ wall, wallHit, nodes, spaces })
     const boundaries = space
       ? space.boundaryFaces
@@ -353,6 +546,24 @@ export function resolvePaintScopeTargets(args: {
   }
 
   if (node.type === 'slab' && scope === 'room') {
+    // A room's floor in the room scope: every finish source of that room (its
+    // floor, painted parts, steps and edge) on every plate of the level, as one
+    // `room:<zoneId>/*` role the zone commits.
+    const floor = parseRoomFinishRole(role)
+    if (floor) {
+      const roomWide = `room:${floor.zoneId}/*`
+      const plates = Object.values(nodes).filter(
+        (other) =>
+          other.type === 'slab' && other.parentId === node.parentId && other.boundary === 'auto',
+      )
+      return (plates.length ? plates : [node]).map((plate) => ({
+        nodeId: plate.id as AnyNodeId,
+        role: roomWide,
+      }))
+    }
+    // A floor plate's own faces have no room scope; below is the hand-drawn
+    // slab's spread over the slabs of its room.
+    if (isFloorPlate(node)) return single
     const centroid = polygonCentroid((node as SlabNode).polygon)
     if (!centroid) return single
     // Space polygons are per-level footprints, and stacked storeys share a
@@ -386,7 +597,7 @@ function materialsEqual(a: unknown, b: unknown): boolean {
   if (Object.is(a, b)) return true
   if (typeof a !== typeof b || a === null || b === null) return false
   if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false
+    if (!(Array.isArray(a) && Array.isArray(b)) || a.length !== b.length) return false
     return a.every((value, index) => materialsEqual(value, b[index]))
   }
   if (typeof a === 'object') {
@@ -401,18 +612,49 @@ function materialsEqual(a: unknown, b: unknown): boolean {
   return false
 }
 
+/**
+ * Split a fan-out into slot writes and roles a kind routes elsewhere — a wall's
+ * `room:<zoneId>` paints the zone, through the wall's own commit, once per role.
+ * Targets without a paint capability (the zone listed for a one-wall room) only
+ * ride along for the preview.
+ */
+function partitionFanout(targets: ReadonlyArray<{ nodeId: AnyNodeId; role: string }>) {
+  const nodes = useScene.getState().nodes
+  const routed = new Map<string, { nodeId: AnyNodeId; role: string }>()
+  const slots: Array<{ nodeId: AnyNodeId; role: string }> = []
+  for (const target of targets) {
+    const node = nodes[target.nodeId]
+    if (!node) continue
+    const capabilities = nodeRegistry.get(node.type)?.capabilities
+    const declared = capabilities?.slots?.(node)
+    const isSlot = declared?.length
+      ? declared.some((slot) => slot.slotId === target.role)
+      : !target.role.includes(':')
+    const key = target.role.includes(':') ? target.role : `${target.nodeId}:${target.role}`
+    if (isSlot) slots.push(target)
+    else if (capabilities?.paint?.commit && !routed.has(key)) routed.set(key, target)
+  }
+  return { routed: [...routed.values()], slots }
+}
+
 /**
  * Apply one paint to many slot-model targets in a single undo step. Resolves
  * the slot ref ONCE — a one-off colour creates a single shared scene material
  * for the whole fan-out, not one per node — then writes every `node.slots[role]`
- * (or deletes it, for the eraser) in one `useScene.setState`. Only ever called
- * for item / wall / slab fan-outs, all of which use the unified slot model.
+ * (or deletes it, for the eraser) in one `useScene.setState`. Routed roles
+ * (see `partitionFanout`) commit through their kind instead.
  */
 export function commitPaintScopeFanout(
-  targets: ReadonlyArray<{ nodeId: AnyNodeId; role: string }>,
+  fanout: ReadonlyArray<{ nodeId: AnyNodeId; role: string }>,
   material: MaterialSchema | undefined,
   materialPreset: string | undefined,
 ): void {
+  const { routed, slots: targets } = partitionFanout(fanout)
+  for (const { nodeId, role } of routed) {
+    const node = useScene.getState().nodes[nodeId]
+    const paint = node ? nodeRegistry.get(node.type)?.capabilities?.paint : undefined
+    if (node && paint?.commit) paint.commit({ node, role, material, materialPreset })
+  }
   if (targets.length === 0) return
   const state = useScene.getState()
 

package/src/lib/panel-rows.ts

@@ -62,12 +62,33 @@ export type PanelRow = { section?: string } & (
 
 export const PANEL_MODEL_EXTENSION = 'pascal:editor/panel-model'
 
+/**
+ * A control the multi-selection inspector renders for every selected node of
+ * a kind at once (derived settings the raw parametrics can't express). `value`
+ * null means the selection is mixed: no option shows as active.
+ */
+export type MultiPanelControl = {
+  id: string
+  kind: 'segmented'
+  /** The parametrics group title the control sits in. */
+  section: string
+  label: string
+  options: ReadonlyArray<{ value: string; label: string }>
+  value: string | null
+  /** Applies to every selected node in one undo step. */
+  onChange: (value: string) => void
+}
+
 export type NodePanelModel<N extends AnyNode = AnyNode> = {
   rows: (context: {
     node: N
     nodes: Record<AnyNodeId, AnyNode>
     update: (patch: Partial<N>) => void
   }) => PanelRow[]
+  multiControls?: (context: {
+    selection: N[]
+    nodes: Record<AnyNodeId, AnyNode>
+  }) => MultiPanelControl[]
 }
 
 export function getNodePanelModel(definition: AnyNodeDefinition | undefined) {

package/src/lib/parametric-node-update.ts

@@ -6,13 +6,14 @@ import {
   useScene,
 } from '@pascal-app/core'
 
-export function commitParametricNodeFields(
+/** A field edit with what its kind's parametrics derive and reconcile from it, as updates. */
+export function parametricNodeUpdates(
   nodeId: AnyNodeId,
   requestedPatch: Partial<AnyNode>,
-): void {
-  const scene = useScene.getState()
-  const node = scene.nodes[nodeId]
-  if (!node) return
+): { id: AnyNodeId; data: Partial<AnyNode> }[] {
+  const nodes = useScene.getState().nodes
+  const node = nodes[nodeId]
+  if (!node) return []
 
   const parametrics = nodeRegistry.get(node.type)?.parametrics as
     | ParametricDescriptor<AnyNode>
@@ -31,7 +32,15 @@ export function commitParametricNodeFields(
   ]
   if (parametrics?.reconcile) {
     const next = { ...node, ...patch } as AnyNode
-    updates.push(...parametrics.reconcile(node, next))
+    updates.push(...parametrics.reconcile(node, next, { ...nodes, [nodeId]: next }))
   }
-  scene.updateNodes(updates)
+  return updates
+}
+
+export function commitParametricNodeFields(
+  nodeId: AnyNodeId,
+  requestedPatch: Partial<AnyNode>,
+): void {
+  const updates = parametricNodeUpdates(nodeId, requestedPatch)
+  if (updates.length) useScene.getState().updateNodes(updates)
 }