@pascal-app/editor 1.0.1 → 1.0.4

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)) {
@@ -216,7 +368,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 +435,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 +456,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 +490,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 +529,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 +545,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 +596,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 +611,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

@@ -0,0 +1,96 @@
+import type { AnyNode, AnyNodeDefinition, AnyNodeId } from '@pascal-app/core'
+
+export type PanelIcon = { color?: string; src?: string }
+
+export type PanelAction = {
+  icon?: PanelIcon
+  disabled?: boolean
+  id: string
+  label: string
+  onSelect?: () => void
+}
+
+export type PanelRow = { section?: string } & (
+  | {
+      id: string
+      kind: 'action'
+      icon?: PanelIcon
+      label: string
+      onSelect?: () => void
+      disabled?: boolean
+    }
+  | {
+      actions: PanelAction[]
+      id: string
+      kind: 'actions'
+    }
+  | {
+      id: string
+      kind: 'choice'
+      label: string
+      onSelect?: () => void
+      value: string
+    }
+  | {
+      getValue: () => string
+      id: string
+      kind: 'subscribed-choice'
+      label: string
+      onSelect?: () => void
+      subscribe: (listener: () => void) => () => void
+    }
+  | {
+      id: string
+      kind: 'cycle'
+      label: string
+      next: () => void
+      previous: () => void
+      value: string
+    }
+  | {
+      id: string
+      kind: 'stepper'
+      label: string
+      max: number
+      min: number
+      onChange: (value: number) => void
+      step: number
+      unit?: string
+      value: number
+    }
+)
+
+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) {
+  return definition?.extensions?.[PANEL_MODEL_EXTENSION] as NodePanelModel | undefined
+}

package/src/lib/panel-tool-options.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from 'bun:test'
+import { createToolHintsStore } from './panel-tool-options'
+
+test('tool hints share subscriptions, react to visibility and chip state, and unsubscribe', () => {
+  let visible = false
+  let value = 'auto'
+  let subscriptions = 0
+  let cleanups = 0
+  const subscribe = (_listener: () => void) => {
+    subscriptions++
+    return () => {
+      cleanups++
+    }
+  }
+  const store = createToolHintsStore([
+    {
+      key: 'P',
+      label: 'Placement',
+      visible: { subscribe, value: () => visible },
+      chip: { subscribe, value: () => value, cycle: () => {}, labels: { auto: 'Auto' } },
+    },
+  ])
+  const cleanup = store.subscribe(() => {})
+  expect(subscriptions).toBe(1)
+  const hidden = store.getSnapshot()
+  visible = true
+  expect(store.getSnapshot()).not.toBe(hidden)
+  const shown = store.getSnapshot()
+  value = 'roof'
+  expect(store.getSnapshot()).not.toBe(shown)
+  expect(store.getSnapshot()).toBe(store.getSnapshot())
+  cleanup()
+  expect(cleanups).toBe(1)
+})

package/src/lib/panel-tool-options.ts

@@ -0,0 +1,46 @@
+'use client'
+
+import { nodeRegistry, type ToolHint, useRegistryVersion } from '@pascal-app/core'
+import { useMemo, useSyncExternalStore } from 'react'
+import useEditor from '../store/use-editor'
+
+export type PanelToolOption = {
+  id: string
+  label: string
+  value: string
+  choices: readonly { value: string; label: string; description?: string }[]
+  set: (value: string) => void
+}
+
+export function createToolHintsStore(hints: readonly ToolHint[]) {
+  return {
+    subscribe(listener: () => void) {
+      const subscriptions = hints.flatMap((hint) => [hint.chip?.subscribe, hint.visible?.subscribe])
+      const cleanups = [...new Set(subscriptions)].flatMap((subscribe) =>
+        subscribe ? [subscribe(listener)] : [],
+      )
+      return () => {
+        for (const cleanup of cleanups) cleanup()
+      }
+    },
+    getSnapshot: () =>
+      JSON.stringify(hints.map((hint) => [hint.visible?.value() ?? true, hint.chip?.value()])),
+  }
+}
+
+export function useVisibleToolHints(hints: readonly ToolHint[] = []) {
+  const draftVertexCount = useEditor((state) => state.draftVertexCount)
+  const store = useMemo(() => createToolHintsStore(hints), [hints])
+  useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot)
+  return hints.filter(
+    (hint) =>
+      !(hint.key === 'Shift' && hint.label === 'Cycle snapping mode') &&
+      (hint.visible?.value() ?? true) &&
+      (hint.minDraftVertices == null || draftVertexCount >= hint.minDraftVertices),
+  )
+}
+
+export function usePanelToolHints(kind: string | null | undefined) {
+  useRegistryVersion()
+  return useVisibleToolHints(kind ? nodeRegistry.get(kind)?.toolHints : undefined)
+}

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

@@ -0,0 +1,37 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  nodeRegistry,
+  type ParametricDescriptor,
+  useScene,
+} from '@pascal-app/core'
+
+export function commitParametricNodeFields(
+  nodeId: AnyNodeId,
+  requestedPatch: Partial<AnyNode>,
+): void {
+  const scene = useScene.getState()
+  const node = scene.nodes[nodeId]
+  if (!node) return
+
+  const parametrics = nodeRegistry.get(node.type)?.parametrics as
+    | ParametricDescriptor<AnyNode>
+    | undefined
+  let patch = requestedPatch as Record<string, unknown>
+  if (parametrics?.derive) {
+    const next = { ...node, ...patch } as AnyNode
+    patch = {
+      ...patch,
+      ...parametrics.derive(next, patch as Partial<AnyNode>, node),
+    }
+  }
+
+  const updates: { id: AnyNodeId; data: Partial<AnyNode> }[] = [
+    { id: nodeId, data: patch as Partial<AnyNode> },
+  ]
+  if (parametrics?.reconcile) {
+    const next = { ...node, ...patch } as AnyNode
+    updates.push(...parametrics.reconcile(node, next, { ...scene.nodes, [nodeId]: next }))
+  }
+  scene.updateNodes(updates)
+}