@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/store/use-measurement-draft.ts

@@ -0,0 +1,570 @@
+'use client'
+
+import {
+  areMeasurementPointsCoplanar,
+  MEASUREMENT_PLANAR_TOLERANCE,
+  type MeasurementAnchor,
+  type MeasurementFeatureAnchor,
+  MeasurementNode,
+  type MeasurementSnapKind,
+  measurementNormal,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+
+export type MeasurementKind = 'distance' | 'angle' | 'area' | 'perimeter' | 'volume'
+export type MeasurementDraftOwner = '2d' | '3d'
+export type MeasurementDraftStage = 'collecting' | 'extruding' | 'ready'
+export type MeasurementAxis = 'x' | 'y' | 'z'
+export type MeasurementPoint = [number, number, number]
+
+export type MeasurementAxisGuide = {
+  axis: MeasurementAxis
+  from: MeasurementPoint
+  to: MeasurementPoint
+  snapped: boolean
+  proximity?: boolean
+}
+
+export type MeasurementSurfacePoint = {
+  point: MeasurementPoint
+  normal: MeasurementPoint
+  targetNodeId: string | null
+  anchor?: MeasurementFeatureAnchor
+  semantic?: {
+    label: string
+    length: number | null
+    snapKind: MeasurementSnapKind
+  }
+}
+
+export type MeasurementVertexDrag = {
+  owner: MeasurementDraftOwner
+  index: number
+  originalPoint: MeasurementPoint
+  originalAnchor: MeasurementFeatureAnchor | null
+  inserted: boolean
+}
+
+export type MeasurementDraftPayload =
+  | { kind: 'distance'; points: [MeasurementAnchor, MeasurementAnchor] }
+  | { kind: 'angle'; points: [MeasurementAnchor, MeasurementAnchor, MeasurementAnchor] }
+  | { kind: 'area'; base: MeasurementAnchor[] }
+  | { kind: 'perimeter'; base: MeasurementAnchor[] }
+  | { kind: 'volume'; base: MeasurementAnchor[]; extrusion: MeasurementPoint }
+
+type MeasurementDraftState = {
+  kind: MeasurementKind
+  owner: MeasurementDraftOwner | null
+  levelId: string | null
+  stage: MeasurementDraftStage
+  points: MeasurementPoint[]
+  anchors: Array<MeasurementFeatureAnchor | null>
+  hover: MeasurementSurfacePoint | null
+  hoverOwner: MeasurementDraftOwner | null
+  axisGuide: MeasurementAxisGuide | null
+  vertexDrag: MeasurementVertexDrag | null
+  collectionPlane: { point: MeasurementPoint; normal: MeasurementPoint } | null
+  baseNormal: MeasurementPoint | null
+  extrusionHeight: number
+  error: string | null
+  setKind(kind: MeasurementKind): void
+  setHover(
+    owner: MeasurementDraftOwner,
+    hover: MeasurementSurfacePoint | null,
+    axisGuide?: MeasurementAxisGuide | null,
+  ): void
+  beginVertexDrag(owner: MeasurementDraftOwner, index: number): boolean
+  beginMidpointVertexDrag(owner: MeasurementDraftOwner, edgeIndex: number): boolean
+  updateDraggedVertex(
+    owner: MeasurementDraftOwner,
+    hover: MeasurementSurfacePoint,
+    axisGuide?: MeasurementAxisGuide | null,
+  ): boolean
+  finishVertexDrag(owner: MeasurementDraftOwner): boolean
+  cancelVertexDrag(owner: MeasurementDraftOwner): boolean
+  addPoint(
+    owner: MeasurementDraftOwner,
+    point: MeasurementPoint,
+    anchor?: MeasurementFeatureAnchor,
+    surfaceNormal?: MeasurementPoint,
+  ): boolean
+  closeBase(owner: MeasurementDraftOwner, preferredNormal?: MeasurementPoint): boolean
+  setExtrusionHeight(owner: MeasurementDraftOwner, height: number): boolean
+  finishExtrusion(owner: MeasurementDraftOwner): boolean
+  removeLast(owner: MeasurementDraftOwner): boolean
+  getCommitPayload(owner: MeasurementDraftOwner): MeasurementDraftPayload | null
+  reset(): void
+}
+
+const MIN_EXTRUSION = 0.001
+
+const clonePoint = (point: MeasurementPoint): MeasurementPoint => [...point]
+
+function normalizePoint(point: MeasurementPoint | undefined): MeasurementPoint | null {
+  if (!point?.every(Number.isFinite)) return null
+  const length = Math.hypot(...point)
+  return length > 1e-9 ? [point[0] / length, point[1] / length, point[2] / length] : null
+}
+
+function projectPointToPlane(
+  point: MeasurementPoint,
+  plane: { point: MeasurementPoint; normal: MeasurementPoint } | null,
+): MeasurementPoint {
+  if (!plane) return clonePoint(point)
+  const distance =
+    (point[0] - plane.point[0]) * plane.normal[0] +
+    (point[1] - plane.point[1]) * plane.normal[1] +
+    (point[2] - plane.point[2]) * plane.normal[2]
+  return [
+    point[0] - plane.normal[0] * distance,
+    point[1] - plane.normal[1] * distance,
+    point[2] - plane.normal[2] * distance,
+  ]
+}
+
+function anchorWithFallback(
+  anchor: MeasurementFeatureAnchor | undefined,
+  fallback: MeasurementPoint,
+): MeasurementFeatureAnchor | null {
+  return anchor ? { ...anchor, fallback: clonePoint(fallback) } : null
+}
+
+export function measurementPolygonMidpoints(
+  points: readonly MeasurementPoint[],
+): Array<{ edgeIndex: number; point: MeasurementPoint }> {
+  if (points.length < 3) return []
+  return points.map((start, edgeIndex) => {
+    const end = points[(edgeIndex + 1) % points.length]!
+    return {
+      edgeIndex,
+      point: [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2, (start[2] + end[2]) / 2],
+    }
+  })
+}
+
+function idleState(kind: MeasurementKind) {
+  return {
+    kind,
+    owner: null,
+    levelId: null,
+    stage: 'collecting' as const,
+    points: [],
+    anchors: [],
+    hover: null,
+    hoverOwner: null,
+    axisGuide: null,
+    vertexDrag: null,
+    collectionPlane: null,
+    baseNormal: null,
+    extrusionHeight: 0,
+    error: null,
+  }
+}
+
+function payloadFor(state: MeasurementDraftState): MeasurementDraftPayload | null {
+  if (state.stage !== 'ready') return null
+
+  const anchorAt = (index: number): MeasurementAnchor =>
+    state.anchors[index] ?? clonePoint(state.points[index]!)
+
+  if (state.kind === 'distance') {
+    const [start, end] = state.points
+    if (!(start && end)) return null
+    return { kind: 'distance', points: [anchorAt(0), anchorAt(1)] }
+  }
+
+  if (state.kind === 'angle') {
+    if (state.points.length !== 3) return null
+    return { kind: 'angle', points: [anchorAt(0), anchorAt(1), anchorAt(2)] }
+  }
+
+  if (state.kind === 'area' || state.kind === 'perimeter') {
+    if (state.points.length < 3) return null
+    return { kind: state.kind, base: state.points.map((_, index) => anchorAt(index)) }
+  }
+
+  if (!(state.baseNormal && state.points.length >= 3)) return null
+  return {
+    kind: 'volume',
+    base: state.points.map((_, index) => anchorAt(index)),
+    extrusion: [
+      state.baseNormal[0] * state.extrusionHeight,
+      state.baseNormal[1] * state.extrusionHeight,
+      state.baseNormal[2] * state.extrusionHeight,
+    ],
+  }
+}
+
+export const useMeasurementDraft = create<MeasurementDraftState>((set, get) => ({
+  ...idleState('distance'),
+
+  setKind: (kind) => set((state) => (state.kind === kind ? state : { ...idleState(kind) })),
+
+  setHover: (owner, hover, axisGuide = null) =>
+    set((state) => {
+      if (state.owner && state.owner !== owner) return state
+      if (state.levelId && state.levelId !== useViewer.getState().selection.levelId) return state
+      if (state.vertexDrag) return state
+      if (!hover && !state.hover && !state.axisGuide) return state
+      return { hover, hoverOwner: hover ? owner : null, axisGuide }
+    }),
+
+  beginVertexDrag: (owner, index) => {
+    const state = get()
+    const point = state.points[index]
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      state.vertexDrag ||
+      !Number.isInteger(index) ||
+      !point
+    ) {
+      return false
+    }
+
+    set({
+      vertexDrag: {
+        owner,
+        index,
+        originalPoint: clonePoint(point),
+        originalAnchor: state.anchors[index] ?? null,
+        inserted: false,
+      },
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  beginMidpointVertexDrag: (owner, edgeIndex) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      state.vertexDrag ||
+      state.kind === 'distance' ||
+      state.kind === 'angle' ||
+      state.points.length < 3 ||
+      !Number.isInteger(edgeIndex) ||
+      edgeIndex < 0 ||
+      edgeIndex >= state.points.length
+    ) {
+      return false
+    }
+
+    const start = state.points[edgeIndex]!
+    const end = state.points[(edgeIndex + 1) % state.points.length]!
+    const midpoint: MeasurementPoint = [
+      (start[0] + end[0]) / 2,
+      (start[1] + end[1]) / 2,
+      (start[2] + end[2]) / 2,
+    ]
+    const index = edgeIndex + 1
+    const points = [...state.points.slice(0, index), midpoint, ...state.points.slice(index)]
+    const anchors = [...state.anchors.slice(0, index), null, ...state.anchors.slice(index)]
+
+    set({
+      points,
+      anchors,
+      vertexDrag: {
+        owner,
+        index,
+        originalPoint: clonePoint(midpoint),
+        originalAnchor: null,
+        inserted: true,
+      },
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  updateDraggedVertex: (owner, hover, axisGuide = null) => {
+    const state = get()
+    const drag = state.vertexDrag
+    if (
+      !drag ||
+      drag.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      ![...hover.point, ...hover.normal].every(Number.isFinite)
+    ) {
+      return false
+    }
+
+    const projectedPoint = projectPointToPlane(hover.point, state.collectionPlane)
+    const points = state.points.map((point, index) =>
+      index === drag.index ? projectedPoint : point,
+    )
+    const anchors = state.anchors.map((anchor, index) =>
+      index === drag.index ? anchorWithFallback(hover.anchor, projectedPoint) : anchor,
+    )
+    set({
+      points,
+      anchors,
+      hover: {
+        point: clonePoint(projectedPoint),
+        normal: clonePoint(hover.normal),
+        targetNodeId: hover.targetNodeId,
+        anchor: hover.anchor,
+        semantic: hover.semantic,
+      },
+      hoverOwner: owner,
+      axisGuide: axisGuide
+        ? {
+            axis: axisGuide.axis,
+            from: clonePoint(axisGuide.from),
+            to: clonePoint(axisGuide.to),
+            snapped: axisGuide.snapped,
+            proximity: axisGuide.proximity,
+          }
+        : null,
+      error: null,
+    })
+    return true
+  },
+
+  finishVertexDrag: (owner) => {
+    const drag = get().vertexDrag
+    if (!drag || drag.owner !== owner) return false
+    set({ vertexDrag: null, hover: null, hoverOwner: null, axisGuide: null, error: null })
+    return true
+  },
+
+  cancelVertexDrag: (owner) => {
+    const state = get()
+    const drag = state.vertexDrag
+    if (!drag || drag.owner !== owner) return false
+    const points = drag.inserted
+      ? state.points.filter((_, index) => index !== drag.index)
+      : state.points.map((point, index) =>
+          index === drag.index ? clonePoint(drag.originalPoint) : point,
+        )
+    const anchors = drag.inserted
+      ? state.anchors.filter((_, index) => index !== drag.index)
+      : state.anchors.map((anchor, index) => (index === drag.index ? drag.originalAnchor : anchor))
+    set({
+      points,
+      anchors,
+      vertexDrag: null,
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  addPoint: (owner, point, anchor, surfaceNormal) => {
+    const state = get()
+    const activeLevelId = useViewer.getState().selection.levelId
+    if (!activeLevelId) return false
+    if (state.stage !== 'collecting' || state.vertexDrag || (state.owner && state.owner !== owner))
+      return false
+    if (state.levelId && state.levelId !== activeLevelId) {
+      set({ error: 'The active level changed. Start a new measurement.' })
+      return false
+    }
+    if (state.kind === 'distance' && state.points.length >= 2) return false
+    if (state.kind === 'angle' && state.points.length >= 3) return false
+
+    const polygon = state.kind === 'area' || state.kind === 'perimeter' || state.kind === 'volume'
+    const projectedPoint = polygon
+      ? projectPointToPlane(point, state.collectionPlane)
+      : clonePoint(point)
+    const points = [...state.points, projectedPoint]
+    const anchors = [...state.anchors, anchorWithFallback(anchor, projectedPoint)]
+    const planeNormal = polygon && state.points.length === 0 ? normalizePoint(surfaceNormal) : null
+    const ready =
+      (state.kind === 'distance' && points.length === 2) ||
+      (state.kind === 'angle' && points.length === 3)
+    set({
+      owner,
+      levelId: state.levelId ?? activeLevelId,
+      points,
+      anchors,
+      collectionPlane: planeNormal
+        ? { point: clonePoint(projectedPoint), normal: planeNormal }
+        : state.collectionPlane,
+      stage: ready ? 'ready' : 'collecting',
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  closeBase: (owner, preferredNormal) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      state.vertexDrag ||
+      state.kind === 'distance' ||
+      state.kind === 'angle' ||
+      state.points.length < 3
+    ) {
+      return false
+    }
+
+    if (!areMeasurementPointsCoplanar(state.points, MEASUREMENT_PLANAR_TOLERANCE)) {
+      set({ error: 'Measurement points must be on one plane.' })
+      return false
+    }
+
+    let normal = measurementNormal(state.points)
+    if (!normal) {
+      set({ error: 'Measurement points must enclose an area.' })
+      return false
+    }
+    if (
+      preferredNormal &&
+      normal[0] * preferredNormal[0] +
+        normal[1] * preferredNormal[1] +
+        normal[2] * preferredNormal[2] <
+        0
+    ) {
+      normal = [
+        normal[0] === 0 ? 0 : -normal[0],
+        normal[1] === 0 ? 0 : -normal[1],
+        normal[2] === 0 ? 0 : -normal[2],
+      ]
+    }
+
+    set({
+      baseNormal: clonePoint(normal),
+      stage: state.kind === 'volume' ? 'extruding' : 'ready',
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  setExtrusionHeight: (owner, height) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'extruding' ||
+      !Number.isFinite(height)
+    ) {
+      return false
+    }
+    set({ extrusionHeight: height, error: null })
+    return true
+  },
+
+  finishExtrusion: (owner) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'extruding' ||
+      Math.abs(state.extrusionHeight) < MIN_EXTRUSION
+    ) {
+      return false
+    }
+    set({ stage: 'ready', hover: null, hoverOwner: null, axisGuide: null, error: null })
+    return true
+  },
+
+  removeLast: (owner) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.vertexDrag ||
+      state.points.length === 0
+    ) {
+      return false
+    }
+
+    const points = state.points.slice(0, -1)
+    const anchors = state.anchors.slice(0, -1)
+    set({
+      owner: points.length > 0 ? owner : null,
+      levelId: points.length > 0 ? state.levelId : null,
+      stage: 'collecting',
+      points,
+      anchors,
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      collectionPlane: points.length > 0 ? state.collectionPlane : null,
+      baseNormal: null,
+      extrusionHeight: 0,
+      error: null,
+    })
+    return true
+  },
+
+  getCommitPayload: (owner) => {
+    const state = get()
+    return state.owner === owner && state.levelId === useViewer.getState().selection.levelId
+      ? payloadFor(state)
+      : null
+  },
+
+  reset: () => set((state) => ({ ...idleState(state.kind) })),
+}))
+
+export function commitMeasurementDraft(owner: MeasurementDraftOwner): MeasurementNode['id'] | null {
+  const draft = useMeasurementDraft.getState()
+  const levelId = draft.levelId
+  if (!levelId || useViewer.getState().selection.levelId !== levelId) {
+    draft.reset()
+    return null
+  }
+  const measurement = draft.getCommitPayload(owner)
+  if (!measurement) return null
+
+  const { createNode, nodes } = useScene.getState()
+  const count = Object.values(nodes).filter((node) => node.type === 'measurement').length
+  const node = MeasurementNode.parse({ name: `Measurement ${count + 1}`, measurement })
+  createNode(node, levelId)
+  draft.reset()
+  return node.id
+}
+
+export function finishMeasurementDraft(
+  owner: MeasurementDraftOwner,
+  preferredNormal?: MeasurementPoint,
+): boolean {
+  const draft = useMeasurementDraft.getState()
+  if (draft.stage === 'collecting') {
+    if (draft.kind === 'distance' || draft.kind === 'angle') return false
+    if (!draft.closeBase(owner, preferredNormal)) return false
+    if (draft.kind === 'area' || draft.kind === 'perimeter') {
+      return commitMeasurementDraft(owner) !== null
+    }
+    return true
+  }
+  if (draft.stage === 'extruding') {
+    if (!draft.finishExtrusion(owner)) return false
+  }
+  return commitMeasurementDraft(owner) !== null
+}
+
+export function handleMeasurementDraftEscape(
+  owner: MeasurementDraftOwner,
+  preferredNormal?: MeasurementPoint,
+): boolean {
+  const draft = useMeasurementDraft.getState()
+  if (draft.owner !== owner) return false
+
+  const preserveArea = draft.kind === 'area' && draft.points.length >= 3
+  if (!finishMeasurementDraft(owner, preferredNormal) && !preserveArea) draft.reset()
+  return true
+}

package/src/store/use-opening-guides.ts

@@ -0,0 +1,41 @@
+// Ephemeral store for the 3D opening proximity/alignment guides published by the
+// door/window move + placement tools during a drag — the wall-plane counterpart
+// of `useAlignmentGuides` (which only carries floor-plane XZ guides). Guides are
+// already transformed into the move tool's render frame — the same building-local
+// frame as the drag cursor (ToolManager's group) — so the renderer stays dumb.
+// Producers clear on commit, cancel, leave, and unmount.
+
+import { create } from 'zustand'
+
+export type OpeningGuideVec3 = [number, number, number]
+
+// A stable identity per guide slot (`sill`, `head`, `gap:left`, `vertical`,
+// `spacing:0`, …) so the renderer can key by semantic role: as the guide set
+// churns each drag tick, a slot that persists keeps its React element — and its
+// drei `<Html>` portal — mounted instead of remounting when the list shape
+// shifts under index keys.
+export type OpeningGuide3D =
+  // A measured line + distance pill: sill (floor → bottom edge), head (top edge
+  // → wall top), or along-wall edge-to-edge proximity.
+  | { kind: 'dimension'; id: string; from: OpeningGuideVec3; to: OpeningGuideVec3; value: number }
+  // A dashed line connecting two openings that share a sill / centre / top.
+  | { kind: 'align-line'; id: string; from: OpeningGuideVec3; to: OpeningGuideVec3 }
+  // A Figma-style "=" badge marking one gap in an equal-spacing run.
+  | { kind: 'badge'; id: string; at: OpeningGuideVec3; value: number }
+
+type OpeningGuidesState = {
+  guides: OpeningGuide3D[]
+  set(guides: OpeningGuide3D[]): void
+  clear(): void
+}
+
+const useOpeningGuides = create<OpeningGuidesState>((set) => ({
+  guides: [],
+  set: (guides) => set({ guides }),
+  // No-op when already empty so the common no-guide hover frame (fallback
+  // cursor, invalid target, roof hover) doesn't push a fresh `[]` and notify
+  // subscribers — the layer would re-render to the same nothing every tick.
+  clear: () => set((s) => (s.guides.length > 0 ? { guides: [] } : s)),
+}))
+
+export default useOpeningGuides

package/src/store/use-path-draft-preview.ts

@@ -0,0 +1,90 @@
+import type { AnyNode } from '@pascal-app/core'
+import { create } from 'zustand'
+
+export type PathDraftKind = 'duct-segment' | 'lineset' | 'liquid-line' | 'pipe-segment'
+export type PathDraftPoint = [number, number, number]
+export type PathDraftParameter = boolean | number | string
+export type PathDraftParameters = Record<string, PathDraftParameter>
+
+type PathDraftPreviewState = {
+  kind: PathDraftKind | null
+  points: PathDraftPoint[]
+  cursor: PathDraftPoint | null
+  parameters: PathDraftParameters
+  relatedNodes: AnyNode[]
+  setDraft(
+    kind: PathDraftKind,
+    points: readonly PathDraftPoint[],
+    cursor: PathDraftPoint | null,
+    parameters?: Readonly<PathDraftParameters>,
+    relatedNodes?: readonly AnyNode[],
+  ): void
+  clear(kind: PathDraftKind): void
+  reset(): void
+}
+
+function pointEquals(a: PathDraftPoint | null, b: PathDraftPoint | null) {
+  return (!a && !b) || Boolean(a && b && a[0] === b[0] && a[1] === b[1] && a[2] === b[2])
+}
+
+function pointsEqual(a: readonly PathDraftPoint[], b: readonly PathDraftPoint[]) {
+  return a.length === b.length && a.every((point, index) => pointEquals(point, b[index] ?? null))
+}
+
+function parametersEqual(a: PathDraftParameters, b: Readonly<PathDraftParameters>) {
+  const keys = Object.keys(a)
+  const nextKeys = Object.keys(b)
+  return keys.length === nextKeys.length && keys.every((key) => a[key] === b[key])
+}
+
+function relatedNodesEqual(a: readonly AnyNode[], b: readonly AnyNode[]) {
+  return (
+    a.length === b.length &&
+    a.every((node, index) => JSON.stringify(node) === JSON.stringify(b[index]))
+  )
+}
+
+const EMPTY_DRAFT: Pick<
+  PathDraftPreviewState,
+  'cursor' | 'kind' | 'parameters' | 'points' | 'relatedNodes'
+> = {
+  cursor: null,
+  kind: null,
+  parameters: {},
+  points: [],
+  relatedNodes: [],
+}
+
+export const usePathDraftPreview = create<PathDraftPreviewState>((set) => ({
+  ...EMPTY_DRAFT,
+  setDraft: (kind, points, cursor, parameters = {}, relatedNodes = []) =>
+    set((state) => {
+      if (
+        state.kind === kind &&
+        pointEquals(state.cursor, cursor) &&
+        pointsEqual(state.points, points) &&
+        parametersEqual(state.parameters, parameters) &&
+        relatedNodesEqual(state.relatedNodes, relatedNodes)
+      ) {
+        return state
+      }
+      return {
+        cursor: cursor ? [...cursor] : null,
+        kind,
+        parameters: { ...parameters },
+        points: points.map((point) => [...point]),
+        relatedNodes: relatedNodes.map((node) => structuredClone(node)),
+      }
+    }),
+  clear: (kind) => set((state) => (state.kind === kind ? EMPTY_DRAFT : state)),
+  reset: () =>
+    set((state) =>
+      state.kind === null &&
+      state.points.length === 0 &&
+      state.cursor === null &&
+      Object.keys(state.parameters).length === 0 &&
+      state.relatedNodes.length === 0
+        ? state
+        : EMPTY_DRAFT,
+    ),
+}))