@pascal-app/editor 1.0.3 → 1.0.5

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

@@ -3,14 +3,24 @@ import {
   type AnyNode,
   type AnyNodeDefinition,
   type AnyNodeId,
+  BuildingNode,
+  beginSceneHistoryPauseSession,
   CabinetModuleNode,
   CabinetNode,
   findLevelAncestorId,
+  getSceneHistoryPauseDepth,
+  type LevelNode,
   nodeRegistry,
+  pauseSceneHistory,
+  RoofNode,
+  RoofSegmentNode,
   registerNode,
+  resumeSceneHistory,
   type SceneCommit,
   subscribeSceneCommits,
   useScene,
+  WallNode,
+  WindowNode,
 } from '@pascal-app/core'
 import { z } from 'zod'
 import {
@@ -187,6 +197,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 +229,132 @@ describe('commitFreshPlacementSubtree', () => {
     expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([])
   })
 
+  // A roof lives on the level above the walls that carry it: one dropped onto them (a duplicate
+  // in hand) goes there in the placement's one step.
+  test('a roof dropped onto the walls that carry it lands on a new Roof level, in the one step', () => {
+    const corners: [number, number][] = [
+      [0, 0],
+      [8, 0],
+      [8, 6],
+      [0, 6],
+    ]
+    const walls = corners.map((start, i) =>
+      WallNode.parse({ parentId: LEVEL_ID, start, end: corners[(i + 1) % 4], height: 2.5 }),
+    )
+    const segment = RoofSegmentNode.parse({ width: 8, depth: 6, wallHeight: 0 })
+    const draft = RoofNode.parse({
+      parentId: LEVEL_ID,
+      visible: false,
+      metadata: { isNew: true },
+      children: [segment.id],
+    })
+    const building = BuildingNode.parse({ children: [LEVEL_ID] })
+    useScene.setState({
+      nodes: {
+        [building.id]: building,
+        [LEVEL_ID]: {
+          ...level([...walls.map((wall) => wall.id), draft.id]),
+          parentId: building.id,
+          height: 2.5,
+        },
+        ...Object.fromEntries(walls.map((wall) => [wall.id, wall])),
+        [draft.id]: draft,
+        [segment.id]: { ...segment, parentId: draft.id },
+      },
+      rootNodeIds: [building.id],
+      collections: {},
+      dirtyNodes: new Set(),
+    } as never)
+    useScene.temporal.getState().clear()
+
+    const committedId = commitFreshPlacementSubtree(draft.id, {
+      position: [4, 2.5, 3],
+      visible: true,
+    } as Partial<AnyNode>)!
+    const nodes = useScene.getState().nodes
+    const roofLevel = nodes[nodes[committedId]!.parentId as AnyNodeId] as LevelNode
+    expect(roofLevel).toMatchObject({ type: 'level', metadata: { role: 'roof' } })
+    expect(roofLevel.children as string[]).toEqual([committedId])
+    expect((nodes[LEVEL_ID] as LevelNode).children as string[]).not.toContain(committedId)
+    expect(useScene.getState().rootNodeIds).toEqual([building.id])
+
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[committedId]).toBeUndefined()
+    expect(useScene.getState().nodes[roofLevel.id]).toBeUndefined()
+  })
+
+  test('a window joined at a corner while in hand stays joined: its partner names the committed window', () => {
+    const wall = WallNode.parse({ id: 'wall_a', parentId: LEVEL_ID, start: [4, 0], end: [0, 0] })
+    const other = WallNode.parse({ id: 'wall_b', parentId: LEVEL_ID, start: [0, 0], end: [0, 3] })
+    const draft = WindowNode.parse({
+      id: 'window_draft',
+      parentId: wall.id,
+      wallId: wall.id,
+      position: [3.5, 1.5, 0],
+      width: 1,
+      visible: false,
+      metadata: { isNew: true },
+      corner: { end: 'end', partnerId: 'window_partner', post: 'none' },
+    })
+    const partner = WindowNode.parse({
+      id: 'window_partner',
+      parentId: other.id,
+      wallId: other.id,
+      position: [0.5, 1.5, 0],
+      width: 1,
+      corner: { end: 'start', partnerId: draft.id, post: 'none' },
+    })
+    useScene.setState({
+      nodes: {
+        [LEVEL_ID]: level([wall.id as AnyNodeId, other.id as AnyNodeId]),
+        [wall.id]: { ...wall, children: [draft.id] } as AnyNode,
+        [other.id]: { ...other, children: [partner.id] } as AnyNode,
+        [draft.id]: draft as AnyNode,
+        [partner.id]: partner as AnyNode,
+      },
+      rootNodeIds: [LEVEL_ID],
+      collections: {},
+      dirtyNodes: new Set(),
+    } as never)
+
+    const committedId = commitFreshPlacementSubtree(draft.id as AnyNodeId, { visible: true })
+
+    const nodes = useScene.getState().nodes as Record<string, AnyNode>
+    expect(committedId).toBeTruthy()
+    expect((nodes[committedId!] as WindowNode).corner?.partnerId).toBe(partner.id)
+    expect((nodes[partner.id] as WindowNode).corner?.partnerId).toBe(committedId!)
+  })
+
+  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 = {
@@ -244,6 +382,16 @@ describe('commitFreshPlacementSubtree', () => {
     expect((source as AnyNode & { children: AnyNodeId[] }).children).toEqual(['item_original'])
   })
 
+  // A copy of one side of a corner window kept naming the original's partner, which never named it
+  // back: a link that made the copy refuse to join another window.
+  test('a copy of one side of a corner window is a plain window', () => {
+    const side = WindowNode.parse({
+      corner: { end: 'end', partnerId: 'window_partner', post: 'none' },
+    })
+    expect((prepareFreshPlacementRootDuplicate(side) as WindowNode).corner).toBeUndefined()
+    expect(side.corner?.partnerId).toBe('window_partner')
+  })
+
   test('commits a duplicated cabinet draft without deleting the original modules', () => {
     seedCabinetRun()
     useScene.temporal.getState().clear()

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

@@ -1,16 +1,24 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  beginSceneHistoryPauseSession,
+  type CloneNodesIntoResult,
   cloneNodesInto,
+  collectionIdsOf,
   collectSubtree,
   createSceneApi,
   type DuplicableConfig,
+  getEffectiveNode,
+  getSceneHistoryPauseDepth,
   getSurfaceProvider,
   nodeRegistry,
   resolveSurfacePlacement,
+  runSceneHistoryDraftWrite,
   type SurfaceRejectReason,
+  seatRoofs,
   useScene,
 } from '@pascal-app/core'
+import { remapNodeReferences } from '@pascal-app/core/clone-scene-graph'
 import { evaluateRecipe, isProceduralItem } from '@pascal-app/core/procedural-items'
 import useInteractionScope from '../store/use-interaction-scope'
 import usePlacementPreview from '../store/use-placement-preview'
@@ -34,6 +42,61 @@ function parentIdOf(node: AnyNode): AnyNodeId | undefined {
   return parentId ?? undefined
 }
 
+/**
+ * The nodes the draft root names, outside its subtree and other than its parent, that name it
+ * back (a corner window's partner, joined while the draft was in hand). The commit gives the
+ * root a new id, so they are rewritten to name the committed node, never the deleted draft.
+ */
+function peerReferenceUpdates(
+  nodes: Readonly<Record<string, AnyNode>>,
+  root: AnyNode,
+  subtreeIds: ReadonlySet<string>,
+  committedId: AnyNodeId,
+): { id: AnyNodeId; data: Partial<AnyNode> }[] {
+  const named = new Set<string>()
+  const visit = (value: unknown) => {
+    if (typeof value === 'string') {
+      if (nodes[value] && !subtreeIds.has(value) && value !== root.parentId) named.add(value)
+    } else if (Array.isArray(value)) value.forEach(visit)
+    else if (value && typeof value === 'object') Object.values(value).forEach(visit)
+  }
+  const {
+    id: _id,
+    parentId: _parentId,
+    children: _children,
+    ...fields
+  } = root as AnyNode & {
+    children?: unknown
+  }
+  visit(fields)
+  const ids = new Map([[root.id, committedId as string]])
+  return [...named].flatMap((id) => {
+    const peer = nodes[id]!
+    const remapped = remapNodeReferences(peer, ids) as Record<string, unknown>
+    const data = Object.fromEntries(
+      Object.entries(remapped).filter(
+        ([key, value]) =>
+          JSON.stringify(value) !== JSON.stringify((peer as Record<string, unknown>)[key]),
+      ),
+    )
+    return Object.keys(data).length ? [{ id: id as AnyNodeId, data: data as Partial<AnyNode> }] : []
+  })
+}
+
+/**
+ * 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
@@ -61,6 +124,8 @@ export function prepareFreshPlacementRootDuplicate(node: AnyNode): AnyNode {
     metadata?: unknown
   }
   delete duplicate.id
+  // A copy of one side of a corner window is a plain window: its partner stays with the original.
+  delete duplicate.corner
   if (Array.isArray(duplicate.children)) duplicate.children = []
   duplicate.metadata = {
     ...getPlacementMetadataRecord(stripPlacementMetadataFlags(duplicate.metadata)),
@@ -114,9 +179,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 +265,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.
@@ -223,9 +301,13 @@ export function commitFreshPlacementSubtree(
     onReject?.(rejection)
     return null
   }
-  const descendants = subtree.descendants.map((node) => cleanPlacementMetadata(node))
+  const descendants = subtree.descendants.map((node) =>
+    cleanPlacementMetadata(getEffectiveNode(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 }
@@ -235,6 +317,12 @@ export function commitFreshPlacementSubtree(
     if (previous === -1) updates.push(merged)
     else updates[previous] = merged
   }
+  const subtreeIds = new Set([rootId, ...descendants.map((node) => node.id)])
+  for (const update of peerReferenceUpdates(scene.nodes, root, subtreeIds, cloned.rootId))
+    if (!updates.some((entry) => entry.id === update.id)) updates.push(update)
+
+  // A roof dropped onto the walls that carry it goes to the level above them, in the same step.
+  const seated = seatRoofs(scene.nodes, { create, update: updates, delete: [rootId] }).changes
 
   const scope = useInteractionScope.getState()
   const factoryCreated =
@@ -243,43 +331,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: seated.create, update: seated.update }),
+    )
   } 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(seated)
+        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()

package/src/lib/geometry-script/author.ts

@@ -0,0 +1,157 @@
+import {
+  type AnyNodeId,
+  type CompiledGeometryScript,
+  GEOMETRY_SCRIPT_MIME_TYPES,
+  GeometryArtifactMetadata,
+  GeometryReuseFields,
+  type GeometryScriptLanguage,
+  type GeometryScriptParamValue,
+  generateId,
+  getArtifactStore,
+  isScriptedNode,
+  runAsSingleSceneHistoryStep,
+  scriptedObjectMeta,
+  useScene,
+} from '@pascal-app/core'
+import {
+  addColumn,
+  addObject,
+  authoredObject,
+  editedScriptLanguage,
+  editedScriptParams,
+  rescriptOpening,
+} from '@pascal-app/core/agent-operations'
+import { compileGeometryScriptInWorker } from './client'
+
+/**
+ * Builds a bpy module and stores its GLB and text, returning their hashes.
+ * Blender runs outside the browser, so the host provides this (the hosted app
+ * calls its Blender service); without one, bpy scripts are refused.
+ */
+export type BlenderScriptBuilder = (input: {
+  code: string
+  params?: Record<string, GeometryScriptParamValue>
+  nodeId: string
+  metadata: GeometryArtifactMetadata
+}) => Promise<CompiledGeometryScript>
+
+let blenderBuilder: BlenderScriptBuilder | null = null
+
+export function configureBlenderScriptBuilder(next: BlenderScriptBuilder | null): void {
+  blenderBuilder = next
+}
+
+/**
+ * The editor's compile step for `add_object`: runs the module (a three.js one
+ * in the worker, a bpy one through the host's Blender builder) and stores the
+ * GLB and the module text, so the core operation can reference both by hash.
+ * Without `code`, the node's stored script is rebuilt; either way an edit keeps
+ * the node's param values it does not override.
+ */
+export async function compileAndStoreGeometryScript(input: {
+  code?: string
+  language?: GeometryScriptLanguage
+  nodeId?: string
+  params?: Record<string, GeometryScriptParamValue>
+  kind?: 'item' | 'door' | 'window' | 'column'
+  inputs?: Record<string, unknown>
+  name?: string
+  description?: string
+  category?: string
+  tags?: string[]
+  provenance?: GeometryArtifactMetadata
+}): Promise<CompiledGeometryScript> {
+  const code = input.code ?? (await storedScript(input.nodeId))
+  const node = input.nodeId ? useScene.getState().nodes[input.nodeId as AnyNodeId] : undefined
+  const language = editedScriptLanguage(node, input)
+  const params = editedScriptParams(node, input.params)
+  const kind =
+    input.kind ??
+    (node?.type === 'door' || node?.type === 'window' || node?.type === 'column'
+      ? node.type
+      : 'item')
+  const nodeId = input.nodeId ?? generateId(kind)
+  const metadata = GeometryArtifactMetadata.parse({
+    ...(isScriptedNode(node) ? scriptedObjectMeta(node) : {}),
+    ...input.provenance,
+    ...GeometryReuseFields.parse(input),
+    kind,
+  })
+  if (language === 'bpy') {
+    if (!blenderBuilder) throw new Error('This editor cannot run Blender (bpy) scripts')
+    return { ...(await blenderBuilder({ code, params, nodeId, metadata })), nodeId }
+  }
+  const { glb, ...compiled } = await compileGeometryScriptInWorker({
+    code,
+    params,
+    inputs: input.inputs,
+  })
+  const context = { nodeId, metadata: { ...metadata, mount: compiled.mount } }
+  const store = getArtifactStore()
+  const [sha256] = await Promise.all([
+    store.put(compiled.sha256, glb, 'model/gltf-binary', context),
+    store.put(
+      compiled.script,
+      new TextEncoder().encode(code),
+      GEOMETRY_SCRIPT_MIME_TYPES.three,
+      context,
+    ),
+  ])
+  return { ...compiled, sha256, nodeId }
+}
+
+/** The module text of an authored object, read back from the artifact store. */
+export async function storedScript(nodeId: string | undefined): Promise<string> {
+  if (!nodeId) throw new Error('Pass the code to build a new object')
+  const node = authoredObject(useScene.getState().nodes, nodeId)
+  const code = await getArtifactStore().text(node.source.script)
+  if (code === null) throw new Error(`The script of ${nodeId} could not be read`)
+  return code
+}
+
+const rebuildGeneration = new Map<string, number>()
+
+/**
+ * Re-runs a scripted node's script with new param values, the inspector's
+ * and resize handles' path: same code, new artifact, one undo step. A slower earlier rebuild of
+ * the same node never overwrites a newer one.
+ */
+export async function rebuildAuthoredObject(
+  nodeId: string,
+  params: Record<string, GeometryScriptParamValue>,
+  /** Where it ends up, when a resize also moves it (a side arrow keeps the opposite edge). */
+  position?: [number, number, number],
+): Promise<void> {
+  const generation = (rebuildGeneration.get(nodeId) ?? 0) + 1
+  rebuildGeneration.set(nodeId, generation)
+  const compiled = await compileAndStoreGeometryScript({ nodeId, params })
+  if (rebuildGeneration.get(nodeId) !== generation) return
+  const changes = rebuildChanges(nodeId, compiled, params, position)
+  runAsSingleSceneHistoryStep(useScene, () => {
+    for (const { id, data } of changes?.update ?? []) {
+      useScene.getState().updateNode(id as AnyNodeId, data)
+    }
+  })
+}
+
+/** What a rebuild changes, through the operation of the node's kind. */
+function rebuildChanges(
+  nodeId: string,
+  compiled: CompiledGeometryScript,
+  params: Record<string, GeometryScriptParamValue>,
+  position: [number, number, number] | undefined,
+) {
+  const nodes = useScene.getState().nodes
+  const context = { activeLevelId: null }
+  switch (nodes[nodeId as AnyNodeId]?.type) {
+    case 'column': {
+      const at = position && { x: position[0], y: position[1], z: position[2] }
+      return addColumn(nodes, { nodeId, compiled, ...at }, context).changes
+    }
+    case 'window':
+    case 'door':
+      return rescriptOpening(nodes, { nodeId, compiled, position }, context).changes
+    default:
+      return addObject(nodes, { params, nodeId, compiled, position }, context).changes
+  }
+}