@pascal-app/editor 1.0.3 → 1.0.4

package/src/lib/floorplan/site-plan/street-name.ts

@@ -0,0 +1,302 @@
+/**
+ * Street names compared the way the Postal Service reads an address (USPS
+ * Publication 28): a name is its directional, its core and its street type,
+ * each spelling brought to the standard abbreviation. "4121 NW 34th St" and
+ * OSM's "Northwest 34th Street" are one street; "Northwest 34th Terrace" is
+ * another — the type is part of the name, and so is the quadrant.
+ */
+
+/**
+ * USPS Publication 28, Appendix C1 — street suffixes: the standard
+ * abbreviation, then every spelling the Postal Service lists for it (lower
+ * case, periods dropped).
+ */
+const PUB28_SUFFIXES: Record<string, readonly string[]> = {
+  aly: ['allee', 'alley', 'ally', 'aly'],
+  anx: ['anex', 'annex', 'annx', 'anx'],
+  arc: ['arc', 'arcade'],
+  ave: ['av', 'ave', 'aven', 'avenu', 'avenue', 'avn', 'avnue'],
+  byu: ['bayoo', 'bayou'],
+  bch: ['bch', 'beach'],
+  bnd: ['bend', 'bnd'],
+  blf: ['blf', 'bluf', 'bluff'],
+  blfs: ['bluffs'],
+  btm: ['bot', 'btm', 'bottm', 'bottom'],
+  blvd: ['blvd', 'boul', 'boulevard', 'boulv'],
+  br: ['br', 'brnch', 'branch'],
+  brg: ['brdge', 'brg', 'bridge'],
+  brk: ['brk', 'brook'],
+  brks: ['brooks'],
+  bg: ['burg'],
+  bgs: ['burgs'],
+  byp: ['byp', 'bypa', 'bypas', 'bypass', 'byps'],
+  cp: ['camp', 'cp', 'cmp'],
+  cyn: ['canyn', 'canyon', 'cnyn'],
+  cpe: ['cape', 'cpe'],
+  cswy: ['causeway', 'causwa', 'cswy'],
+  ctr: ['cen', 'cent', 'center', 'centr', 'centre', 'cnter', 'cntr', 'ctr'],
+  ctrs: ['centers'],
+  cir: ['cir', 'circ', 'circl', 'circle', 'crcl', 'crcle'],
+  cirs: ['circles'],
+  clf: ['clf', 'cliff'],
+  clfs: ['clfs', 'cliffs'],
+  clb: ['clb', 'club'],
+  cmn: ['common'],
+  cmns: ['commons'],
+  cor: ['cor', 'corner'],
+  cors: ['corners', 'cors'],
+  crse: ['course', 'crse'],
+  ct: ['court', 'ct'],
+  cts: ['courts', 'cts'],
+  cv: ['cove', 'cv'],
+  cvs: ['coves'],
+  crk: ['creek', 'crk'],
+  cres: ['crescent', 'cres', 'crsent', 'crsnt'],
+  crst: ['crest'],
+  xing: ['crossing', 'crssng', 'xing'],
+  xrd: ['crossroad'],
+  xrds: ['crossroads'],
+  curv: ['curve'],
+  dl: ['dale', 'dl'],
+  dm: ['dam', 'dm'],
+  dv: ['div', 'divide', 'dv', 'dvd'],
+  dr: ['dr', 'driv', 'drive', 'drv'],
+  drs: ['drives'],
+  est: ['est', 'estate'],
+  ests: ['estates', 'ests'],
+  expy: ['exp', 'expr', 'express', 'expressway', 'expw', 'expy'],
+  ext: ['ext', 'extension', 'extn', 'extnsn'],
+  exts: ['exts'],
+  fall: ['fall'],
+  fls: ['falls', 'fls'],
+  fry: ['ferry', 'frry', 'fry'],
+  fld: ['field', 'fld'],
+  flds: ['fields', 'flds'],
+  flt: ['flat', 'flt'],
+  flts: ['flats', 'flts'],
+  frd: ['ford', 'frd'],
+  frds: ['fords'],
+  frst: ['forest', 'forests', 'frst'],
+  frg: ['forg', 'forge', 'frg'],
+  frgs: ['forges'],
+  frk: ['fork', 'frk'],
+  frks: ['forks', 'frks'],
+  ft: ['fort', 'frt', 'ft'],
+  fwy: ['freeway', 'freewy', 'frway', 'frwy', 'fwy'],
+  gdn: ['garden', 'gardn', 'grden', 'grdn'],
+  gdns: ['gardens', 'gdns', 'grdns'],
+  gtwy: ['gateway', 'gatewy', 'gatway', 'gtway', 'gtwy'],
+  gln: ['glen', 'gln'],
+  glns: ['glens'],
+  grn: ['green', 'grn'],
+  grns: ['greens'],
+  grv: ['grov', 'grove', 'grv'],
+  grvs: ['groves'],
+  hbr: ['harb', 'harbor', 'harbr', 'hbr', 'hrbor'],
+  hbrs: ['harbors'],
+  hvn: ['haven', 'hvn'],
+  hts: ['ht', 'hts'],
+  hwy: ['highway', 'highwy', 'hiway', 'hiwy', 'hway', 'hwy'],
+  hl: ['hill', 'hl'],
+  hls: ['hills', 'hls'],
+  holw: ['hllw', 'hollow', 'hollows', 'holw', 'holws'],
+  inlt: ['inlt'],
+  is: ['is', 'island', 'islnd'],
+  iss: ['islands', 'islnds', 'iss'],
+  isle: ['isle', 'isles'],
+  jct: ['jct', 'jction', 'jctn', 'junction', 'junctn', 'juncton'],
+  jcts: ['jctns', 'jcts', 'junctions'],
+  ky: ['key', 'ky'],
+  kys: ['keys', 'kys'],
+  knl: ['knl', 'knol', 'knoll'],
+  knls: ['knls', 'knolls'],
+  lk: ['lk', 'lake'],
+  lks: ['lks', 'lakes'],
+  land: ['land'],
+  lndg: ['landing', 'lndg', 'lndng'],
+  ln: ['lane', 'ln'],
+  lgt: ['lgt', 'light'],
+  lgts: ['lights'],
+  lf: ['lf', 'loaf'],
+  lck: ['lck', 'lock'],
+  lcks: ['lcks', 'locks'],
+  ldg: ['ldg', 'ldge', 'lodg', 'lodge'],
+  loop: ['loop', 'loops'],
+  mall: ['mall'],
+  mnr: ['mnr', 'manor'],
+  mnrs: ['manors', 'mnrs'],
+  mdw: ['meadow'],
+  mdws: ['mdw', 'mdws', 'meadows', 'medows'],
+  mews: ['mews'],
+  ml: ['mill'],
+  mls: ['mills'],
+  msn: ['missn', 'mssn'],
+  mtwy: ['motorway'],
+  mt: ['mnt', 'mt', 'mount'],
+  mtn: ['mntain', 'mntn', 'mountain', 'mountin', 'mtin', 'mtn'],
+  mtns: ['mntns', 'mountains'],
+  nck: ['nck', 'neck'],
+  orch: ['orch', 'orchard', 'orchrd'],
+  oval: ['oval', 'ovl'],
+  opas: ['overpass'],
+  park: ['park', 'prk', 'parks'],
+  pkwy: ['parkway', 'parkwy', 'pkway', 'pkwy', 'pky', 'parkways', 'pkwys'],
+  pass: ['pass'],
+  psge: ['passage'],
+  path: ['path', 'paths'],
+  pike: ['pike', 'pikes'],
+  pne: ['pine'],
+  pnes: ['pines', 'pnes'],
+  pl: ['pl', 'place'],
+  pln: ['plain', 'pln'],
+  plns: ['plains', 'plns'],
+  plz: ['plaza', 'plz', 'plza'],
+  pt: ['point', 'pt'],
+  pts: ['points', 'pts'],
+  prt: ['port', 'prt'],
+  prts: ['ports', 'prts'],
+  pr: ['pr', 'prairie', 'prr'],
+  radl: ['rad', 'radial', 'radiel', 'radl'],
+  ramp: ['ramp'],
+  rnch: ['ranch', 'ranches', 'rnch', 'rnchs'],
+  rpd: ['rapid', 'rpd'],
+  rpds: ['rapids', 'rpds'],
+  rst: ['rest', 'rst'],
+  rdg: ['rdg', 'rdge', 'ridge'],
+  rdgs: ['rdgs', 'ridges'],
+  riv: ['riv', 'river', 'rvr', 'rivr'],
+  rd: ['rd', 'road'],
+  rds: ['roads', 'rds'],
+  rte: ['route'],
+  row: ['row'],
+  rue: ['rue'],
+  run: ['run'],
+  shl: ['shl', 'shoal'],
+  shls: ['shls', 'shoals'],
+  shr: ['shoar', 'shore', 'shr'],
+  shrs: ['shoars', 'shores', 'shrs'],
+  skwy: ['skyway'],
+  spg: ['spg', 'spng', 'spring', 'sprng'],
+  spgs: ['spgs', 'spngs', 'springs', 'sprngs'],
+  spur: ['spur', 'spurs'],
+  sq: ['sq', 'sqr', 'sqre', 'squ', 'square'],
+  sqs: ['sqrs', 'squares'],
+  sta: ['sta', 'station', 'statn', 'stn'],
+  stra: ['stra', 'strav', 'straven', 'stravenue', 'stravn', 'strvn', 'strvnue'],
+  strm: ['stream', 'streme', 'strm'],
+  st: ['street', 'strt', 'st', 'str'],
+  sts: ['streets'],
+  smt: ['smt', 'sumit', 'sumitt', 'summit'],
+  ter: ['ter', 'terr', 'terrace'],
+  trwy: ['throughway'],
+  trce: ['trace', 'traces', 'trce'],
+  trak: ['track', 'tracks', 'trak', 'trk', 'trks'],
+  trfy: ['trafficway'],
+  trl: ['trail', 'trails', 'trl', 'trls'],
+  trlr: ['trailer', 'trlr', 'trlrs'],
+  tunl: ['tunel', 'tunl', 'tunls', 'tunnel', 'tunnels', 'tunnl'],
+  tpke: ['trnpk', 'turnpike', 'turnpk'],
+  upas: ['underpass'],
+  un: ['un', 'union'],
+  uns: ['unions'],
+  vly: ['valley', 'vally', 'vlly', 'vly'],
+  vlys: ['valleys', 'vlys'],
+  via: ['vdct', 'via', 'viadct', 'viaduct'],
+  vw: ['view', 'vw'],
+  vws: ['views', 'vws'],
+  vlg: ['vill', 'villag', 'village', 'villg', 'villiage', 'vlg'],
+  vlgs: ['villages', 'vlgs'],
+  vl: ['ville', 'vl'],
+  vis: ['vis', 'vist', 'vista', 'vst', 'vsta'],
+  walk: ['walk', 'walks'],
+  wall: ['wall'],
+  way: ['wy', 'way'],
+  ways: ['ways'],
+  wl: ['well'],
+  wls: ['wells', 'wls'],
+}
+
+/** Any listed spelling of a street type → its Pub. 28 abbreviation. */
+const SUFFIX: ReadonlyMap<string, string> = new Map(
+  Object.entries(PUB28_SUFFIXES).flatMap(([abbr, spellings]) =>
+    spellings.map((s) => [s, abbr] as const),
+  ),
+)
+
+/** Pub. 28 directionals, spelled out or abbreviated → the abbreviation. */
+const DIRECTIONAL: ReadonlyMap<string, string> = new Map([
+  ['n', 'n'],
+  ['s', 's'],
+  ['e', 'e'],
+  ['w', 'w'],
+  ['ne', 'ne'],
+  ['nw', 'nw'],
+  ['se', 'se'],
+  ['sw', 'sw'],
+  ['north', 'n'],
+  ['south', 's'],
+  ['east', 'e'],
+  ['west', 'w'],
+  ['northeast', 'ne'],
+  ['northwest', 'nw'],
+  ['southeast', 'se'],
+  ['southwest', 'sw'],
+])
+
+export interface StreetName {
+  /** The directional before the name ("nw"), '' when none. */
+  pre: string
+  /** The name itself, lower case ("34th", "castro"). */
+  name: string
+  /** The street type as its Pub. 28 abbreviation ("st", "ter"), '' when the name carries none. */
+  type: string
+  /** The directional after the type ("n" in "1st St N"), '' when none. */
+  post: string
+}
+
+/**
+ * A street line read into its parts: the house number dropped, the type and
+ * the directionals standardised. A word is only read as a type or a
+ * directional when a name is left beside it ("North St" is the street named
+ * North).
+ */
+export function parseStreetName(s: string | null | undefined): StreetName {
+  const words = String(s ?? '')
+    .toLowerCase()
+    .replace(/\./g, '')
+    .replace(/^\s*\d+[a-z]?(?:-\d+[a-z]?)?\s+/, '')
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim()
+    .split(' ')
+    .filter(Boolean)
+  let post = ''
+  let type = ''
+  let pre = ''
+  if (words.length >= 2 && DIRECTIONAL.has(words[words.length - 1] as string))
+    post = DIRECTIONAL.get(words.pop() as string) as string
+  if (words.length >= 2 && SUFFIX.has(words[words.length - 1] as string))
+    type = SUFFIX.get(words.pop() as string) as string
+  if (words.length >= 2 && DIRECTIONAL.has(words[0] as string))
+    pre = DIRECTIONAL.get(words.shift() as string) as string
+  return { pre, name: words.join(' '), type, post }
+}
+
+/**
+ * Do two street lines name the same street? The names must agree, and so
+ * must the street types and the directionals wherever both lines give one:
+ * "NW 34th St" is "Northwest 34th Street" (and "34th Street"), never
+ * "Northwest 34th Terrace" or "SW 34th St". A line with no name matches
+ * nothing.
+ */
+export function sameStreet(
+  a: string | StreetName | null | undefined,
+  b: string | StreetName | null | undefined,
+): boolean {
+  const x = typeof a === 'object' && a !== null ? a : parseStreetName(a)
+  const y = typeof b === 'object' && b !== null ? b : parseStreetName(b)
+  if (!x.name || x.name !== y.name) return false
+  if (x.type && y.type && x.type !== y.type) return false
+  const dx = [x.pre, x.post].filter(Boolean).join(' ')
+  const dy = [y.pre, y.post].filter(Boolean).join(' ')
+  return !dx || !dy || dx === dy
+}

package/src/lib/floorplan/site-plan/yards.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'bun:test'
+import { castYardDimensions, castYardDimensionsOriented, type Pt } from './geometry'
+
+// 20 m × 30 m lot centred on the origin, y south
+const LOT: Pt[] = [
+  [-10, -15],
+  [10, -15],
+  [10, 15],
+  [-10, 15],
+]
+const box = (w: number, d: number, cx: number, cz: number, yaw: number): Pt[] => {
+  const c = Math.cos(yaw)
+  const s = Math.sin(yaw)
+  const corners: Pt[] = [
+    [-w / 2, -d / 2],
+    [w / 2, -d / 2],
+    [w / 2, d / 2],
+    [-w / 2, d / 2],
+  ]
+  return corners.map(([lx, lz]) => [cx + c * lx + s * lz, cz - s * lx + c * lz])
+}
+const by = (yards: ReturnType<typeof castYardDimensions>) =>
+  Object.fromEntries(yards.map((y) => [y.side, Math.round(y.distance * 1000) / 1000]))
+
+describe('castYardDimensionsOriented', () => {
+  test('with no rotation it is the axis-aligned cast', () => {
+    const house = box(8, 10, 0, -2, 0)
+    const oriented = castYardDimensionsOriented(LOT, [house], 0)
+    const bbox = castYardDimensions(LOT, { minX: -4, minY: -7, maxX: 4, maxY: 3 })
+    expect(by(oriented)).toEqual(by(bbox))
+    expect(by(oriented)).toEqual({ north: 8, south: 12, west: 6, east: 6 })
+  })
+
+  test('a house turned 90° measures square to its own faces', () => {
+    // 8 wide × 10 deep, turned a quarter: its 10 m side now runs east-west
+    const house = box(8, 10, 0, -2, Math.PI / 2)
+    const yards = by(castYardDimensionsOriented(LOT, [house], Math.PI / 2))
+    expect(yards).toEqual({ north: 9, south: 13, west: 5, east: 5 })
+  })
+
+  test('a house on a diagonal reads its true yards, not the bbox ones', () => {
+    // a 10 × 10 house turned 45° at the origin: its corners reach 7.07 m out,
+    // its faces 5 m — the axis-aligned bbox would put the north yard at 7.93
+    const house = box(10, 10, 0, 0, Math.PI / 4)
+    const oriented = castYardDimensionsOriented(LOT, [house], Math.PI / 4)
+    for (const y of oriented) {
+      // each face midpoint sits 5 m from the centre; the ray runs diagonally to the lot line
+      const fromDist = Math.hypot(y.from[0], y.from[1])
+      expect(fromDist).toBeCloseTo(5, 9)
+    }
+    const bbox = castYardDimensions(LOT, { minX: -7.071, minY: -7.071, maxX: 7.071, maxY: 7.071 })
+    expect(by(bbox).north).toBeCloseTo(7.929, 3)
+    expect(oriented.length).toBe(4)
+  })
+
+  test('no footprint, no yards', () => {
+    expect(castYardDimensionsOriented(LOT, [], 0.3)).toEqual([])
+    expect(
+      castYardDimensionsOriented(
+        [
+          [0, 0],
+          [1, 0],
+        ],
+        [box(1, 1, 0, 0, 0)],
+        0,
+      ),
+    ).toEqual([])
+  })
+})

package/src/lib/floorplan/types.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, ItemNode, Point2D, StairNode, StairSegmentNode } from '@pascal-app/core'
+import type { AnyNode, ItemNode, Point2D } from '@pascal-app/core'
 
 export type FloorplanNodeTransform = {
   position: Point2D
@@ -21,27 +21,6 @@ export type FloorplanItemEntry = {
   depth: number
 }
 
-export type FloorplanStairSegmentEntry = {
-  centerLine: FloorplanLineSegment | null
-  innerPolygon: Point2D[]
-  segment: StairSegmentNode
-  polygon: Point2D[]
-  treadBars: Point2D[][]
-  treadThickness: number
-}
-
-export type FloorplanStairArrowEntry = {
-  head: Point2D[]
-  polyline: Point2D[]
-}
-
-export type FloorplanStairEntry = {
-  arrow: FloorplanStairArrowEntry | null
-  hitPolygons: Point2D[][]
-  stair: StairNode
-  segments: FloorplanStairSegmentEntry[]
-}
-
 export type FloorplanSelectionBounds = {
   minX: number
   maxX: number
@@ -49,9 +28,4 @@ export type FloorplanSelectionBounds = {
   maxY: number
 }
 
-export type StairSegmentTransform = {
-  position: [number, number, number]
-  rotation: number
-}
-
 export type LevelDescendantMap = ReadonlyMap<string, AnyNode>

package/src/lib/fresh-planar-placement.test.ts

@@ -3,11 +3,15 @@ import {
   type AnyNode,
   type AnyNodeDefinition,
   type AnyNodeId,
+  beginSceneHistoryPauseSession,
   CabinetModuleNode,
   CabinetNode,
   findLevelAncestorId,
+  getSceneHistoryPauseDepth,
   nodeRegistry,
+  pauseSceneHistory,
   registerNode,
+  resumeSceneHistory,
   type SceneCommit,
   subscribeSceneCommits,
   useScene,
@@ -187,6 +191,8 @@ describe('commitFreshPlacementSubtree', () => {
     } as Partial<AnyNode>)
     unsubscribe()
 
+    // A legacy caller's raw pause is kept after the one recorded step.
+    expect(useScene.temporal.getState().isTracking).toBe(false)
     expect(committedId).toBeTruthy()
     expect(committedId).not.toBe(SHELF_ID)
     const finalId = committedId as AnyNodeId
@@ -217,6 +223,36 @@ describe('commitFreshPlacementSubtree', () => {
     expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([])
   })
 
+  test("never records inside another owner's pause", () => {
+    pauseSceneHistory(useScene)
+    try {
+      const committedId = commitFreshPlacementSubtree(SHELF_ID, {
+        position: [2, 0, 3],
+        visible: true,
+      } as Partial<AnyNode>)
+      expect(committedId).toBeTruthy()
+      expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+      expect(useScene.temporal.getState().isTracking).toBe(false)
+      expect(getSceneHistoryPauseDepth()).toBe(1)
+    } finally {
+      resumeSceneHistory(useScene)
+    }
+  })
+
+  test("lifts the moving node's gesture session for its one step and keeps it after", () => {
+    const overlay = beginSceneHistoryPauseSession(useScene, { gesture: SHELF_ID })
+    const committedId = commitFreshPlacementSubtree(SHELF_ID, {
+      position: [2, 0, 3],
+      visible: true,
+    } as Partial<AnyNode>)
+    expect(committedId).toBeTruthy()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    expect(useScene.temporal.getState().isTracking).toBe(false)
+    overlay.end()
+    expect(getSceneHistoryPauseDepth()).toBe(0)
+    expect(useScene.temporal.getState().isTracking).toBe(true)
+  })
+
   test('uses the subtree contract for childless variants and never aliases root-only children', () => {
     registerCabinetClonePrepTestKind()
     const childlessCabinet = {

package/src/lib/fresh-planar-placement.ts

@@ -1,13 +1,18 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  beginSceneHistoryPauseSession,
+  type CloneNodesIntoResult,
   cloneNodesInto,
+  collectionIdsOf,
   collectSubtree,
   createSceneApi,
   type DuplicableConfig,
+  getSceneHistoryPauseDepth,
   getSurfaceProvider,
   nodeRegistry,
   resolveSurfacePlacement,
+  runSceneHistoryDraftWrite,
   type SurfaceRejectReason,
   useScene,
 } from '@pascal-app/core'
@@ -34,6 +39,20 @@ function parentIdOf(node: AnyNode): AnyNodeId | undefined {
   return parentId ?? undefined
 }
 
+/**
+ * Create ops for a clone of scene nodes: each copy joins the collections its
+ * source is in, whatever its kind.
+ */
+export function copyCreateOps(cloned: CloneNodesIntoResult, parentId: AnyNodeId | undefined) {
+  const collections = useScene.getState().collections
+  const sourceIds = new Map([...cloned.idMap].map(([source, copy]) => [copy, source]))
+  return cloned.nodes.map((node, index) => ({
+    node,
+    ...(index === 0 && parentId ? { parentId } : {}),
+    collectionIds: collectionIdsOf(collections, sourceIds.get(node.id as AnyNodeId)!),
+  }))
+}
+
 function duplicableConfigFor(node: AnyNode): DuplicableConfig | null {
   const duplicable = nodeRegistry.get(node.type)?.capabilities?.duplicable
   return duplicable && typeof duplicable === 'object' ? duplicable : null
@@ -114,9 +133,7 @@ export function createFreshPlacementSubtree(
   })
 
   scene.applyNodeChanges({
-    create: cloned.nodes.map((node, index) =>
-      index === 0 && parentId ? { node, parentId } : { node },
-    ),
+    create: copyCreateOps(cloned, parentId),
     update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceAttachmentId(subtree.root)),
   })
 
@@ -202,6 +219,21 @@ function namedSurfaceRejection(
   return null
 }
 
+/**
+ * Runs a placement's one committing write as a history step. The moving node's gesture
+ * sessions (the 2D move overlay's) are lifted for it; any other owner's pause still holds, so
+ * the write then records nothing. A legacy caller's raw `temporal.pause()` is kept afterwards.
+ */
+function recordPlacementStep(rootId: AnyNodeId, wasTracking: boolean, write: () => void): void {
+  const step = beginSceneHistoryPauseSession(useScene, { gesture: rootId })
+  try {
+    step.commitStep(write)
+  } finally {
+    step.end()
+    if (!wasTracking && getSceneHistoryPauseDepth() === 0) useScene.temporal.getState().pause()
+  }
+}
+
 /**
  * Replace the draft in one validated write. History already excludes fresh
  * subtrees, so this records one creation without first deleting the preview.
@@ -226,6 +258,8 @@ export function commitFreshPlacementSubtree(
   const descendants = subtree.descendants.map((node) => cleanPlacementMetadata(node))
   const parentId = parentIdOf(root)
   const cloned = cloneNodesInto([root, ...descendants], { rootId, parentId })
+  // The drafts' memberships, read before they are deleted.
+  const create = copyCreateOps(cloned, parentId)
   const updates = surfaceAttachmentUpdates(rootId, null, null)
   for (const update of surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId)) {
     const attachments = { ...(update.data as { attachments: Record<string, string> }).attachments }
@@ -243,43 +277,32 @@ export function commitFreshPlacementSubtree(
   const wasTracking = temporal.isTracking
   if (!factoryCreated && descendants.length === 0 && surfaceId === null) {
     // Preserve the established root-only lifecycle for placements outside the subtree factory.
-    if (wasTracking) temporal.pause()
-    updateSurfaceNode(rootId, {}, null)
-    useScene.getState().deleteNode(rootId)
-    temporal.resume()
-    useScene.getState().applyNodeChanges({
-      create: cloned.nodes.map((node, index) =>
-        index === 0 && parentId ? { node, parentId } : { node },
-      ),
-      update: updates,
+    runSceneHistoryDraftWrite(() => {
+      updateSurfaceNode(rootId, {}, null)
+      useScene.getState().deleteNode(rootId)
     })
-    if (!wasTracking) temporal.pause()
+    recordPlacementStep(rootId, wasTracking, () =>
+      useScene.getState().applyNodeChanges({ create, update: updates }),
+    )
   } else {
-    temporal.resume()
-    try {
-      // applyNodeChanges validates the complete proposed graph before publishing any part of it.
-      scene.applyNodeChanges({
-        delete: [rootId],
-        create: cloned.nodes.map((node, index) =>
-          index === 0 && parentId ? { node, parentId } : { node },
-        ),
-        update: updates,
-      })
-      for (const node of [subtree.root, ...subtree.descendants]) scene.clearDirty(node.id)
-    } catch (error) {
-      // Zustand publishes before notifying subscribers. A subscriber error must restore
-      // the draft and its ownership/history, never masquerade as a placement refusal.
-      temporal.pause()
+    recordPlacementStep(rootId, wasTracking, () => {
       try {
-        if (useScene.getState() !== scene) useScene.setState(scene, true)
-      } finally {
-        useInteractionScope.setState(scope)
-        useScene.temporal.setState(temporal)
+        // applyNodeChanges validates the complete proposed graph before publishing any part of it.
+        scene.applyNodeChanges({ delete: [rootId], create, update: updates })
+        for (const node of [subtree.root, ...subtree.descendants]) scene.clearDirty(node.id)
+      } catch (error) {
+        // Zustand publishes before notifying subscribers. A subscriber error must restore
+        // the draft and its ownership/history, never masquerade as a placement refusal.
+        useScene.temporal.getState().pause()
+        try {
+          if (useScene.getState() !== scene) useScene.setState(scene, true)
+        } finally {
+          useInteractionScope.setState(scope)
+          useScene.temporal.setState(temporal)
+        }
+        throw error
       }
-      throw error
-    } finally {
-      if (!wasTracking) temporal.pause()
-    }
+    })
   }
   useInteractionScope.getState().finishSubtree(rootId)
   if (usePlacementPreview.getState().node?.id === rootId) usePlacementPreview.getState().clear()